//-----------------------------
//Includes
//-----------------------------
#include "MantidKernel/System.h"
#include <Poco/Path.h>
#include <boost/shared_ptr.hpp>
#include <climits>
#include <limits>
#include <cfloat>
#include <typeinfo>
#include <map>
// Need OS defined functions
#ifdef _WIN32
#include <windows.h>
#elif defined __linux__
#include <unistd.h>
#include <fstream>
#include <sstream>
#include <algorithm>
#include <iomanip>
#include <iostream>
#elif defined __APPLE__
#include <mach-o/dyld.h>
#endif
// MG 16/07/09: Some forward declarations of things from API. I need this so
// that the typeid function in getUnmangledTypeName knows about them
// This way I don't need to actually include the headers and I don't
// introduce unwanted dependencies
namespace Mantid
{
namespace API
{
class Workspace;
class MatrixWorkspace;
class ITableWorkspace;
class IMDEventWorkspace;
class IMDWorkspace;
class IEventWorkspace;
}
namespace DataObjects
{
class EventWorkspace;
class PeaksWorkspace;
}
namespace MDDataObjects
{
class MDWorkspace;
}
}
int Mantid::EMPTY_INT()
{
return INT_MAX;
}
double Mantid::EMPTY_DBL()
{
return DBL_MAX/2;
}
/// Constructor
Mantid::Kernel::RegistrationHelper::RegistrationHelper(int)
{
}
/**
* Get the directory containing the program executable
* @returns A string containing the path of the directory
* containing the executable, including a trailing slash
*/
std::string Mantid::Kernel::getDirectoryOfExecutable()
{
//std::cout << "getDirectoryOfExecutable is " << Poco::Path(getPathToExecutable()).parent().toString() << std::endl
return Poco::Path(getPathToExecutable()).parent().toString();
}
/**
* Get the full path the the program executable. This is not necessarily MantidPlot or a main
* program since if we are running through Python, it is the Python executable that is considered
* as the executing program
* @returns A string containing the full path the the executable
*/
std::string Mantid::Kernel::getPathToExecutable()
{
std::string execpath("");
const size_t LEN(1024);
char pBuf[LEN];
// The linux function returns an int, the Windows & Mac ones an unsigned type
#ifndef __linux__
unsigned
#endif
int bytes(0);
#ifdef _WIN32
bytes = GetModuleFileName(NULL, pBuf, LEN);
#elif defined __linux__
char szTmp[32];
sprintf(szTmp, "/proc/%d/exe", getpid());
bytes = readlink(szTmp, pBuf, LEN);
#elif defined __APPLE__
// Two calls to _NSGetExecutablePath required - first to get size of buffer
_NSGetExecutablePath(pBuf,&bytes);
const int success = _NSGetExecutablePath(pBuf,&bytes);
if (success < 0) bytes = 1025;
#endif
if( bytes > 0 && bytes < 1024 )
{
pBuf[bytes] = '\0';
execpath = std::string(pBuf);
}
return execpath;
}
/**
* Check if the path is on a network drive
* @param path :: The path to be checked
* @return True if the path is on a network drive.
*/
bool Mantid::Kernel::isNetworkDrive(const std::string & path)
{
#ifdef _WIN32
// if path is relative get the full one
char buff[MAX_PATH];
GetFullPathName(path.c_str(),MAX_PATH,buff,NULL);
std::string fullName(buff);
size_t i = fullName.find(':');
// if the full path doesn't contain a drive letter assume it's on the network
if (i == std::string::npos) return true;
fullName.erase(i+1);
fullName += '\\'; // make sure the name has the trailing backslash
UINT type = GetDriveType(fullName.c_str());
return DRIVE_REMOTE == type;
#elif defined __linux__
// This information is only present in the /proc/mounts file on linux. There are no drives on
// linux only mount locations therefore the test will have to check the path against
// entries in /proc/mounts to see if the filesystem type is NFS or SMB (any others ????)
// Each line corresponds to a particular mounted location
// 1st column - device name
// 2nd column - mounted location
// 3rd column - filesystem type commonly ext2, ext3 for hard drives and NFS or SMB for
// network locations
std::ifstream mntfile("/proc/mounts");
std::string txtread("");
while( getline(mntfile, txtread) )
{
std::istringstream strm(txtread);
std::string devname(""), mntpoint(""), fstype("");
strm >> devname >> mntpoint >> fstype;
if( !strm ) continue;
// I can't be sure that the file system type is always lower case
std::transform(fstype.begin(), fstype.end(), fstype.begin(), toupper);
// Skip the current line if the file system isn't a network one
if( fstype != "NFS" && fstype != "SMB" ) continue;
// Now we have a line containing a network filesystem and just need to check if the path
// supplied contains the mount location. There is a small complication in that the mount
// points within the file have certain characters transformed into their octal
// representations, for example spaces->040.
std::string::size_type idx = mntpoint.find("\\0");
if( idx != std::string::npos )
{
std::string oct = mntpoint.substr(idx + 1, 3);
strm.str(oct);
int printch(-1);
strm.setf( std::ios::oct, std::ios::basefield );
strm >> printch;
if( printch != -1 )
{
mntpoint = mntpoint.substr(0, idx) + static_cast<char>(printch) + mntpoint.substr(idx + 4);
}
// Search for this at the start of the path
if( path.find(mntpoint) == 0 ) return true;
}
}
return false;
#else
// Not yet implemented for the mac
return false;
#endif
}
/**
* Get the unmangled name of the given typestring for some common types that we use. Note that
* this is just a lookup and NOT an unmangling algorithm
* @param type :: A pointer to the type_info object for this type
* @returns An unmangled version of the name
*/
std::string Mantid::Kernel::getUnmangledTypeName(const std::type_info& type)
{
// Compile a lookup table. This is a static local variable that
// will get initialized when the function is first used
static std::map<std::string, std::string> typestrings;
if( typestrings.empty() )
{
typestrings.insert(std::make_pair(typeid(char).name(), std::string("letter")));
typestrings.insert(std::make_pair(typeid(int).name(), std::string("number")));
typestrings.insert(std::make_pair(typeid(long long).name(), std::string("number")));
typestrings.insert(std::make_pair(typeid(double).name(), std::string("number")));
typestrings.insert(std::make_pair(typeid(bool).name(), std::string("boolean")));
typestrings.insert(std::make_pair(typeid(std::string).name(), std::string("string")));
typestrings.insert(std::make_pair(typeid(std::vector<std::string>).name(), std::string("str list")));
typestrings.insert(std::make_pair(typeid(std::vector<int>).name(), std::string("int list")));
typestrings.insert(std::make_pair(typeid(std::vector<double>).name(), std::string("dbl list")));
//Workspaces
typestrings.insert(std::make_pair(typeid(boost::shared_ptr<Mantid::API::Workspace>).name(), std::string("Workspace")));
typestrings.insert(std::make_pair(typeid(boost::shared_ptr<Mantid::API::MatrixWorkspace>).name(), std::string("MatrixWorkspace")));
typestrings.insert(std::make_pair(typeid(boost::shared_ptr<Mantid::API::ITableWorkspace>).name(), std::string("TableWorkspace")));
typestrings.insert(std::make_pair(typeid(boost::shared_ptr<Mantid::API::IMDWorkspace>).name(), std::string("IMDWorkspace")));
typestrings.insert(std::make_pair(typeid(boost::shared_ptr<Mantid::API::IMDEventWorkspace>).name(), std::string("MDEventWorkspace")));
typestrings.insert(std::make_pair(typeid(boost::shared_ptr<Mantid::API::IEventWorkspace>).name(), std::string("IEventWorkspace")));
typestrings.insert(std::make_pair(typeid(boost::shared_ptr<Mantid::DataObjects::EventWorkspace>).name(), std::string("EventWorkspace")));
typestrings.insert(std::make_pair(typeid(boost::shared_ptr<Mantid::DataObjects::PeaksWorkspace>).name(), std::string("PeaksWorkspace")));
typestrings.insert(std::make_pair(typeid(boost::shared_ptr<Mantid::MDDataObjects::MDWorkspace>).name(), std::string("MDWorkspace")));
}
std::map<std::string, std::string>::const_iterator mitr = typestrings.find(type.name());
if( mitr != typestrings.end() )
{
return mitr->second;
}
return type.name();
}