System Namespace Reference

Note: OS specific details for environment resolution. More...

Classes
class	PathResolver
struct	PROCESS_BASIC_INFORMATION
struct	QUOTA_LIMITS
	Process Quotas NtQueryInformationProcess using ProcessQuotaLimits NtQueryInformationProcess using ProcessPooledQuotaLimits NtSetInformationProcess using ProcessQuotaLimits. More...
struct	IO_COUNTERS
	Process I/O Counters NtQueryInformationProcess using ProcessIoCounters. More...
struct	VM_COUNTERS
	Process Virtual Memory Counters NtQueryInformationProcess using ProcessVmCounters. More...
struct	POOLED_USAGE_AND_LIMITS
	Process Pooled Quota Usage and Limits NtQueryInformationProcess using ProcessPooledUsageAndLimits. More...
struct	KERNEL_USER_TIMES
	Process/Thread System and User Time NtQueryInformationProcess using ProcessTimes NtQueryInformationThread using ThreadTimes. More...
class	ProcessDescriptor
	Provides access to process information. More...
Typedefs
typedef void *	ImageHandle
	Definition of an image handle.
typedef void *	ProcessHandle
	Definition of the process handle.
typedef unsigned long(*	EntryPoint )(const unsigned long iid, void **ppvObject)
	Definition of the "generic" DLL entry point function.
typedef void *(*	Creator )()
	Definition of the "generic" DLL entry point function.
typedef void *	ThreadHandle
	A Thread handle.
typedef struct _PEB *	PPEB
	Basic Process Information NtQueryInformationProcess using ProcessBasicInfo.
Enumerations
enum	MemoryUnit {   Byte, kByte, MByte, GByte,   TByte, PByte, EByte }
	Unit of memory. More...
enum	ModuleType { UNKNOWN, SHAREDLIB, EXECUTABLE }
enum	InfoType {   NoFetch, RemainTime, Times, ProcessBasics,   PriorityBoost, Memory, Quota, System,   Modules, IO }
	Enumeration for fetching information. More...
enum	TimeType {   Year, Month, Day, Hour,   Min, Sec, milliSec, microSec,   nanoSec }
	Time type for conversion. More...
enum	PR_file_type { PR_regular_file, PR_directory }
enum	PR_search_type { PR_local, PR_recursive }
enum	ProcessInfoCommand {   ProcessBasicInformation, ProcessQuotaLimits, ProcessIoCounters, ProcessVmCounters,   ProcessTimes, ProcessBasePriority, ProcessRaisePriority, ProcessDebugPort,   ProcessExceptionPort, ProcessAccessToken, ProcessLdtInformation, ProcessLdtSize,   ProcessDefaultHardErrorMode, ProcessIoPortHandlers, ProcessPooledUsageAndLimits, ProcessWorkingSetWatch,   ProcessUserModeIOPL, ProcessEnableAlignmentFaultFixup, ProcessPriorityClass, ProcessWx86Information,   ProcessHandleCount, ProcessAffinityMask, ProcessPriorityBoost, MaxProcessInfoClass,   ProcessEllapsedTime }
Functions
GAUDI_API long	breakExecution ()
	Break the execution of the application and invoke the debugger.
GAUDI_API long	breakExecution (long pid)
	Break the execution of the application and invoke the debugger in a remote process.
GAUDI_API std::string	homeDirectory ()
GAUDI_API std::string	tempDirectory ()
GAUDI_API StatusCode	resolveEnv (const std::string &var, std::string &res, int recusions=124)
GAUDI_API long	adjustMemory (MemoryUnit typ, long value)
	Convert time from kByte to requested representation (Experts only).
GAUDI_API long	procID ()
	Basic Process Information: Process ID.
GAUDI_API long	parentID (InfoType fetch=ProcessBasics, long pid=-1)
	Basic Process Information: Parent's process ID.
GAUDI_API long	affinityMask (InfoType fetch=ProcessBasics, long pid=-1)
	Basic Process Information: Affinity mask.
GAUDI_API long	exitStatus (InfoType fetch=ProcessBasics, long pid=-1)
	Basic Process Information: Exit status (does not really make sense for the running process, but for others!).
GAUDI_API long	basePriority (InfoType fetch=ProcessBasics, long pid=-1)
	Basic Process Information: Base priority.
GAUDI_API long	priorityBoost (InfoType fetch=PriorityBoost, long pid=-1)
	Basic Process Information: priority boost.
GAUDI_API long	numPageFault (InfoType fetch=Memory, long pid=-1)
	Basic Process Information: Number of page faults.
GAUDI_API long	pagefileUsage (MemoryUnit unit=kByte, InfoType fetch=Memory, long pid=-1)
	Basic Process Information: Current page file usage.
GAUDI_API long	pagefileUsagePeak (MemoryUnit unit=kByte, InfoType fetch=Memory, long pid=-1)
	Basic Process Information: Peak usage of page file.
GAUDI_API long	pagefileUsageLimit (MemoryUnit unit=kByte, InfoType fetch=Quota, long pid=-1)
	Basic Process Information: Peak usage of page file.
GAUDI_API long	nonPagedMemory (MemoryUnit unit=kByte, InfoType fetch=Memory, long pid=-1)
	Basic Process Information: Current usage of non paged memory.
GAUDI_API long	nonPagedMemoryPeak (MemoryUnit unit=kByte, InfoType fetch=Memory, long pid=-1)
	Basic Process Information: Peak usage of non paged memory.
GAUDI_API long	nonPagedMemoryLimit (MemoryUnit unit=kByte, InfoType fetch=Quota, long pid=-1)
	System Process Limits: Maximum amount of non-paged memory this process is allowed to use.
GAUDI_API long	pagedMemory (MemoryUnit unit=kByte, InfoType fetch=Memory, long pid=-1)
	Basic Process Information: Amount of paged memory currently occupied by the process 'pid'.
GAUDI_API long	pagedMemoryPeak (MemoryUnit unit=kByte, InfoType fetch=Memory, long pid=-1)
	Basic Process Information: Maximum of paged memory occupied by the process 'pid'.
GAUDI_API long	pagedMemoryLimit (MemoryUnit unit=kByte, InfoType fetch=Quota, long pid=-1)
	Basic Process Information: Amount of paged memory that can be occupied by the process 'pid'.
GAUDI_API long	minMemoryLimit (MemoryUnit unit=kByte, InfoType fetch=Quota, long pid=-1)
	System Process Limits: Minimum amount of virtual memory this process may use.
GAUDI_API long	maxMemoryLimit (MemoryUnit unit=kByte, InfoType fetch=Quota, long pid=-1)
	System Process Limits: Maximum amount of virtual memory this process is allowed to use.
GAUDI_API long	mappedMemory (MemoryUnit unit=kByte, InfoType fetch=Memory, long pid=-1)
	Basic Process Information: priority boost.
GAUDI_API long	mappedMemoryPeak (MemoryUnit unit=kByte, InfoType fetch=Memory, long pid=-1)
	Basic Process Information: priority boost.
GAUDI_API long	virtualMemory (MemoryUnit unit=kByte, InfoType fetch=Memory, long pid=-1)
	Basic Process Information: priority boost.
GAUDI_API long	virtualMemoryPeak (MemoryUnit unit=kByte, InfoType fetch=Memory, long pid=-1)
	Basic Process Information: priority boost.
GAUDI_API long	virtualMemoryLimit (MemoryUnit unit=kByte, InfoType fetch=Quota, long pid=-1)
	System Process Limits: Maximum amount of the page file this process is allowed to use.
GAUDI_API const std::string &	moduleName ()
	Get the name of the (executable/DLL) file without file-type.
GAUDI_API const std::string &	moduleNameFull ()
	Get the full name of the (executable/DLL) file.
GAUDI_API ModuleType	moduleType ()
	Get type of the module.
GAUDI_API ProcessHandle	processHandle ()
	Handle to running process.
GAUDI_API ImageHandle	moduleHandle ()
	Handle to currently executed module.
GAUDI_API ImageHandle	exeHandle ()
	Handle to the executable file running.
GAUDI_API const std::string &	exeName ()
	Name of the executable file running.
GAUDI_API const std::vector < std::string >	linkedModules ()
	Vector of names of linked modules.
GAUDI_API void	setModuleHandle (ImageHandle handle)
	Attach module handle.
GAUDI_API PathResolver::SearchPathStatus	PathResolverCheckSearchPath (const std::string &search_path)
GAUDI_API std::string	PathResolverFindDirectory (const std::string &logical_file_name, const std::string &search_path)
GAUDI_API std::string	PathResolverFindDirectoryFromList (const std::string &logical_file_name, const std::string &search_list)
GAUDI_API std::string	PathResolverFindFile (const std::string &logical_file_name, const std::string &search_path)
GAUDI_API std::string	PathResolverFindFileFromList (const std::string &logical_file_name, const std::string &search_list)
GAUDI_API std::string	PathResolverFindXMLFile (const std::string &logical_file_name)
GAUDI_API std::string	PathResolverFindDataFile (const std::string &logical_file_name)
GAUDI_API unsigned long	loadDynamicLib (const std::string &name, ImageHandle *handle)
	Load dynamic link library.
GAUDI_API unsigned long	unloadDynamicLib (ImageHandle handle)
	unload dynamic link library
GAUDI_API unsigned long	getProcedureByName (ImageHandle handle, const std::string &name, EntryPoint *pFunction)
	Get a specific function defined in the DLL.
GAUDI_API unsigned long	getProcedureByName (ImageHandle handle, const std::string &name, Creator *pFunction)
	Get a specific function defined in the DLL.
GAUDI_API unsigned long	getLastError ()
	Get last system known error.
GAUDI_API const std::string	getLastErrorString ()
	Get last system error as string.
GAUDI_API const std::string	getErrorString (unsigned long error)
	Retrieve error code as string for a given error.
GAUDI_API const std::string	typeinfoName (const std::type_info &)
	Get platform independent information about the class type.
GAUDI_API const std::string	typeinfoName (const char *)
GAUDI_API const std::string &	hostName ()
	Host name.
GAUDI_API const std::string &	osName ()
	OS name.
GAUDI_API const std::string &	osVersion ()
	OS version.
GAUDI_API const std::string &	machineType ()
	Machine type.
GAUDI_API const std::string &	accountName ()
	User login name.
GAUDI_API long	numCmdLineArgs ()
	Number of arguments passed to the commandline.
GAUDI_API long	argc ()
	Number of arguments passed to the commandline (==numCmdLineArgs()); just to match argv call...
GAUDI_API const std::vector < std::string >	cmdLineArgs ()
	Command line arguments including executable name as arg[0] as vector of strings.
GAUDI_API char **	argv ()
	char** command line arguments including executable name as arg[0]; You may not modify them!
GAUDI_API const std::string	getEnv (const char *var)
	get a particular environment variable
GAUDI_API const std::vector < std::string >	getEnv ()
	get all environment variables
GAUDI_API int	setEnv (const std::string &name, const std::string &value, int overwrite=1)
	Set an environment variables.
ThreadHandle	threadSelf ()
	thread handle "accessor"
GAUDI_API int	backTrace (void **addresses, const int depth)
GAUDI_API bool	backTrace (std::string &btrace, const int depth, const int offset=0)
GAUDI_API bool	getStackLevel (void *addresses, void *&addr, std::string &fnc, std::string &lib)
GAUDI_API longlong	adjustTime (TimeType typ, longlong timevalue)
	Convert time from OS native time to requested representation (Experts only).
GAUDI_API longlong	ellapsedTime (TimeType typ=milliSec, InfoType fetch=Times, long pid=-1)
	Ellapsed time since start of process in milli seconds.
GAUDI_API longlong	kernelTime (TimeType typ=milliSec, InfoType fetch=Times, long pid=-1)
	CPU kernel mode time of process in milli seconds.
GAUDI_API longlong	userTime (TimeType typ=milliSec, InfoType fetch=Times, long pid=-1)
	CPU user mode time of process in milli seconds.
GAUDI_API longlong	cpuTime (TimeType typ=milliSec, InfoType fetch=Times, long pid=-1)
	Consumed CPU time of process in milli seconds.
GAUDI_API longlong	remainingTime (TimeType typ=milliSec, InfoType fetch=Quota, long pid=-1)
	Maximum processing time left for this process.
GAUDI_API longlong	creationTime (TimeType typ=milliSec, InfoType fetch=Times, long pid=-1)
	Process Creation time.
GAUDI_API longlong	systemStart (TimeType typ=Sec)
	Maximum processing time left for this process.
GAUDI_API longlong	upTime (TimeType typ=Hour)
	Maximum processing time left for this process.
GAUDI_API longlong	currentTime (TimeType typ=milliSec)
	Retrieve absolute system time.
GAUDI_API longlong	tickCount ()
	Retrieve the number of ticks since system startup.
static void	PR_compress_path (std::string &dir)
static void	PR_dirname (const std::string &file_name, std::string &result)
static bool	PR_absolute_path (const std::string &name)
static void	PR_basename (const std::string &file_name, std::string &result)
static bool	PR_test_exist (const std::string &name, std::string &real_name, PR_file_type file_type)
static void	PR_scan_dir (const std::string &dir_name, std::vector< std::string > &list)
static bool	PR_find (const std::string &search_base, const std::string &logical_file_prefix, const std::string &logical_file_name, PR_file_type file_type, PathResolver::SearchType search_type, std::string &result)
static bool	PR_find_from_list (const std::string &logical_file_name, const std::string &search_list, PR_file_type file_type, PathResolver::SearchType search_type, std::string &result)
System::ProcessDescriptor *	getProcess ()
	Retrieve Process structure.
int	backTrace (void **addresses __attribute__((unused)), const int depth __attribute__((unused)))
bool	getStackLevel (void *addresses __attribute__((unused)), void *&addr __attribute__((unused)), std::string &fnc __attribute__((unused)), std::string &lib __attribute__((unused)))

---

Detailed Description

Note: OS specific details for environment resolution.

Note: OS specific details for process timing.

Note: OS specific details as well as Gaudi details may not occur in this definition file, because this header is the used by both, the OS specific implementations and the gaudi specific implementation.

ModuleInfo: OS specific details to access at run-time the module configuration of the process.

Note: OS specific details for memory usage.

Entrypoints:

Author:

: M.Frank

Version:

: 1.0

Entrypoints:

• basePriority Base priority
• procID Process ID
• parentID Parent's process ID
• affinityMask Affinity mask
• exitStatus Exit status
• priorityBoost Priority boost
• numPageFault Number of page faults
• pagefileUsage Current page file usage
• pagefileUsagePeak Peak usage of page file
• nonPagedMemory Current usage of non paged memory
• nonPagedMemoryPeak Peak usage of non paged memory
• nonPagedMemoryLimit Maximum amount of non-paged memory this process is allowed to use
• pagedMemory Amount of paged memory currently occupied
• pagedMemoryPeak Maximum of paged memory occupied by the process
• pagedMemoryLimit paged memory that can be occupied by the process
• memorySize Size of currently occupied memory
• memorySizePeak Maximum memory occupied by the process
• memoryLimit Amount of memory that can be occupied by the process
• virtualMemorySize Virtual memory size currenly occupied
• peakVirtualMemorySize Maximum amount of virtual memory occupied
• virtualMemoryLimit Amount of virtual memory that can be occupied by the process
• minMemoryLimit Minimum amount of virtual memory this process may use
• maxMemoryLimit Maximum amount of virtual memory this process is allowed to use
• mappedMemorySize Currenly mapped virtual memory size
• mappedMemorySizePeak Peak mapped virtual memory size

Author:

: M.Frank

Version:

: 1.0

M.Frank

Since e.g. IID is defined in both, this would lead automatically to complete comilation failures.....

Author:

M.Frank

Entrypoints:

• remainingTime returns the time the process could still execute
• ellapsedTime: returns ellapsed time since program start
• kernelTime: returns the amount of time the process has spent in kernel mode
• userTime: returns the amount of time the process has spent in user mode
• cpuTime: returns kernel+user time

On Windows NT Time is expressed as the amount of time that has elapsed since midnight on January 1, 1601 at Greenwich, England.

On Unix time is expressed as the amount of time that has elapsed since midnight on January 1, 1970 at Greenwich, England.

History :

    +---------+----------------------------------------------+--------+
    |    Date |                 Comment                      | Who    |
    +---------+----------------------------------------------+--------+
    | 11/11/00| Initial version.                             | MF     |
    +---------+----------------------------------------------+--------+
    

Author:

: M.Frank

Version:

: 1.0

---

Typedef Documentation

typedef void*(* System::Creator)()

Definition of the "generic" DLL entry point function.

Definition at line 38 of file System.h.

typedef unsigned long(* System::EntryPoint)(const unsigned long iid, void **ppvObject)

Definition of the "generic" DLL entry point function.

Definition at line 36 of file System.h.

typedef void * System::ImageHandle

Definition of an image handle.

Definition at line 30 of file ModuleInfo.h.

typedef struct _PEB* System::PPEB

Basic Process Information NtQueryInformationProcess using ProcessBasicInfo.

Definition at line 18 of file ProcessDescriptor.h.

typedef void * System::ProcessHandle

Definition of the process handle.

Definition at line 32 of file ModuleInfo.h.

typedef void* System::ThreadHandle

A Thread handle.

Definition at line 91 of file System.h.

---

Enumeration Type Documentation

enum System::InfoType

Enumeration for fetching information.

Enumerator:

NoFetch
RemainTime
Times
ProcessBasics
PriorityBoost
Memory
Quota
System
Modules
IO

Definition at line 18 of file SystemBase.h.

                  {   NoFetch, 
                      RemainTime, 
                      Times, 
                      ProcessBasics, 
                      PriorityBoost, 
                      Memory, 
                      Quota,
                      System, 
                      Modules, 
                      IO };

enum System::MemoryUnit

Unit of memory.

Enumerator:

Byte
kByte
MByte
GByte
TByte
PByte
EByte

Definition at line 57 of file Memory.h.

{ Byte, kByte, MByte, GByte, TByte, PByte, EByte };

enum System::ModuleType

Enumerator:

UNKNOWN
SHAREDLIB
EXECUTABLE

Definition at line 28 of file ModuleInfo.h.

{ UNKNOWN, SHAREDLIB, EXECUTABLE };

enum System::PR_file_type

Enumerator:

PR_regular_file
PR_directory

Definition at line 24 of file PathResolver.cpp.

  {
    PR_regular_file,
    PR_directory
  } PR_file_type;

enum System::PR_search_type

Enumerator:

PR_local
PR_recursive

Definition at line 30 of file PathResolver.cpp.

             {
  PR_local,
  PR_recursive } PR_search_type;

enum System::ProcessInfoCommand

Enumerator:

ProcessBasicInformation
ProcessQuotaLimits
ProcessIoCounters
ProcessVmCounters
ProcessTimes
ProcessBasePriority
ProcessRaisePriority
ProcessDebugPort
ProcessExceptionPort
ProcessAccessToken
ProcessLdtInformation
ProcessLdtSize
ProcessDefaultHardErrorMode
ProcessIoPortHandlers
ProcessPooledUsageAndLimits
ProcessWorkingSetWatch
ProcessUserModeIOPL
ProcessEnableAlignmentFaultFixup
ProcessPriorityClass
ProcessWx86Information
ProcessHandleCount
ProcessAffinityMask
ProcessPriorityBoost
MaxProcessInfoClass
ProcessEllapsedTime

Definition at line 21 of file ProcessDescriptor.cpp.

                          {
      ProcessBasicInformation,
      ProcessQuotaLimits,
      ProcessIoCounters,
      ProcessVmCounters,
      ProcessTimes,
      ProcessBasePriority,
      ProcessRaisePriority,
      ProcessDebugPort,
      ProcessExceptionPort,
      ProcessAccessToken,
      ProcessLdtInformation,
      ProcessLdtSize,
      ProcessDefaultHardErrorMode,
      ProcessIoPortHandlers,          // Note: this is kernel mode only
      ProcessPooledUsageAndLimits,
      ProcessWorkingSetWatch,
      ProcessUserModeIOPL,
      ProcessEnableAlignmentFaultFixup,
      ProcessPriorityClass,
      ProcessWx86Information,
      ProcessHandleCount,
      ProcessAffinityMask,
      ProcessPriorityBoost,
      MaxProcessInfoClass,  //
      ProcessEllapsedTime
  };

enum System::TimeType

Time type for conversion.

Enumerator:

Year
Month
Day
Hour
Min
Sec
milliSec
microSec
nanoSec

Definition at line 53 of file Timing.h.

{ Year, Month, Day, Hour, Min, Sec, milliSec, microSec, nanoSec };

---

Function Documentation

const std::string & System::accountName

(

)

User login name.

Definition at line 564 of file System.cpp.

                                     {
  static std::string account = "";
  if ( account == "" ) {
#ifdef _WIN32
    char buffer[512];
    unsigned long buflen = sizeof(buffer);
    ::GetUserName(buffer, &buflen);
    account = buffer;
#else
    const char* acct = ::getlogin();
    if ( 0 == acct ) acct = ::getenv("LOGNAME");
    if ( 0 == acct ) acct = ::getenv("USER");
    account = (acct) ? acct : "Unknown";
#endif
  }
  return account;
}

long System::adjustMemory	(	MemoryUnit	typ,
		long	value
	)

Convert time from kByte to requested representation (Experts only).

Convert requested memory value from kByte to requested value.

Definition at line 35 of file Memory.cpp.

                                                          {
  if ( value != -1 )    {
    switch ( unit )   {
    case Byte:      value =       value;    break;
    case kByte:     value =       value/1024;    break;
    case MByte:     value =      (value/1024)/1024;    break;
    case GByte:     value =     ((value/1024)/1024)/1024;    break;
    case TByte:     value =    (((value/1024)/1024)/1024)/1024;    break;
    case PByte:     value =   ((((value/1024)/1024)/1024)/1024)/1024;    break;
    case EByte:     value =  (((((value/1024)/1024)/1024)/1024)/1024)/1024;    break;
    default:        value =  -1;    break;
    }
  }
  return value;
}

longlong System::adjustTime	(	TimeType	typ,
		longlong	timevalue
	)

Convert time from OS native time to requested representation (Experts only).

unfortunately "-ansi" flag turn off teh correct definition of CLK_TCK and forces it to be equal CLOCKS_PER_SEC, it is wrong!

t /= CLOCKS_PER_SEC; // needs division by clock tick unit

Definition at line 38 of file Timing.cpp.

                                                      {
  if ( t != -1 )   {
#ifndef _WIN32
    //  t /= CLK_TCK ;     // needs division by clock tick unit

#endif
    switch( typ )   {
    case Year:      t /= 365;
    case Day:       t /= 24;
    case Hour:      t /= 60;
    case Min:       t /= 60;
    case Sec:       t /= 1000;
    case milliSec:  t /= 1000;
    case microSec:  t /= 10;                    break;
    case nanoSec:   t *= 100;                   break;
    case Month:     t /= (12*24*3600);
                    t /= 10000000;              break;
    default:                                    break;
    }
  }
  return t;
}

long System::affinityMask	(	InfoType	fetch = ProcessBasics,
		long	pid = -1
	)

Basic Process Information: Affinity mask.

Definition at line 74 of file Memory.cpp.

                                                    {
  PROCESS_BASIC_INFORMATION info;
  if ( fetch != NoFetch && getProcess()->query(pid, ProcessBasics, &info) )
    return info.AffinityMask;
  return 0;
}

long System::argc

(

)

Number of arguments passed to the commandline (==numCmdLineArgs()); just to match argv call...

Number of arguments passed to the commandline.

Definition at line 588 of file System.cpp.

                     {
  return cmdLineArgs().size();
}

char ** System::argv

(

)

char** command line arguments including executable name as arg[0]; You may not modify them!

Const char** command line arguments including executable name as arg[0].

added by I.B.

Definition at line 650 of file System.cpp.

                       {
  if( s_argvChars.empty() ) { cmdLineArgs(); }  

  // We rely here on the fact that a vector's allocation table is contiguous
  return (char**)&s_argvChars[0];
}

int System::backTrace	(	void **addresses	__attribute__(unused),
		const int depth	__attribute__(unused)
	)

Definition at line 693 of file System.cpp.

{

#ifdef __linux

  int count = backtrace( addresses, depth );
  if ( count > 0 ) {
    return count;
  } else {
    return 0;
  }

#else // windows and osx parts not implemented
  return 0;
#endif

}

bool System::backTrace	(	std::string &	btrace,
		const int	depth,
		const int	offset = 0
	)

Definition at line 712 of file System.cpp.

{
  // Always hide the first two levels of the stack trace (that's us)
  const int totalOffset = offset + 2;
  const int totalDepth = depth + totalOffset;

  std::string fnc, lib;

  void** addresses = (void**) malloc(totalDepth*sizeof(void *));
  if ( addresses != 0 ){
    int count = System::backTrace(addresses,totalDepth);
    for (int i = totalOffset; i < count; ++i) {
      void *addr = 0;

      if (System::getStackLevel(addresses[i],addr,fnc,lib)) {
        std::ostringstream ost;
        ost << "#" << std::setw(3) << std::setiosflags( std::ios::left ) << i-totalOffset+1;
        ost << std::hex << addr << std::dec << " " << fnc << "  [" << lib << "]" << std::endl;
        btrace += ost.str();
      }
    }
    free(addresses);
  }
  else {
    free(addresses);
    return false;
  }

  return true;
}

GAUDI_API int System::backTrace	(	void **	addresses,
		const int	depth
	)

long System::basePriority	(	InfoType	fetch = ProcessBasics,
		long	pid = -1
	)

Basic Process Information: Base priority.

Definition at line 52 of file Memory.cpp.

                                                    {
  PROCESS_BASIC_INFORMATION info;
  if ( fetch != NoFetch && getProcess()->query(pid, ProcessBasics, &info) )
    return info.BasePriority;
  return 0;
}

long System::breakExecution

(

long

pid

)

Break the execution of the application and invoke the debugger in a remote process.

Break the execution of the application and invoke the debugger on a possibly remote process.

Definition at line 47 of file Debugger.cpp.

                                      {
#ifdef _WIN32
  long result = 0;
  if ( pid == Win::_getpid() )    {
    _asm int 3
    return 1;
  }
  else    {
    Win::LPTHREAD_START_ROUTINE fun;
    Win::HANDLE th, ph;
    Win::HINSTANCE mh;
    Win::DWORD id;
    mh = Win::LoadLibrary( "Kernel32" );
    if ( 0 != mh )    {
      fun = (Win::LPTHREAD_START_ROUTINE)Win::GetProcAddress(mh, "DebugBreak");
      if ( 0 != fun )   {
        ph = Win::OpenProcess (PROCESS_ALL_ACCESS, TRUE, pid);
        if ( 0 != ph )      {
          th = Win::CreateRemoteThread(ph,NULL,0,fun,0,0,&id);
          if ( 0 != th )   {
            Win::CloseHandle(th);
            result = 1;
          }
          Win::CloseHandle(ph);
        }
      }
      Win::FreeLibrary(mh);
    }
  }
  if ( result != 1 ) result = Win::GetLastError();
  return result;
#else
  // I have no clu how to do this in linux
  return pid;
#endif
}

long System::breakExecution

(

)

Break the execution of the application and invoke the debugger.

Definition at line 36 of file Debugger.cpp.

                              {
#ifdef _WIN32
  _asm int 3
  return 1;
#else
  // I have no clu how to do this in linux
  return 0;
#endif
}

const std::vector< std::string > System::cmdLineArgs

(

)

Command line arguments including executable name as arg[0] as vector of strings.

Const char** command line arguments including executable name as arg[0].

Definition at line 593 of file System.cpp.

                                                  {
  if ( s_argvChars.size() == 0 )    {
    char exe[1024];
#ifdef _WIN32
    // For compatibility with UNIX we CANNOT use strtok!
    // If we would use strtok, options like -g="My world" at
    // the command line level would result on NT in TWO options
    // instead in one as in UNIX.
    char *next, *tmp1, *tmp2;
    for(LPTSTR cmd = ::GetCommandLine(); *cmd; cmd=next)   {
      memset(exe,0,sizeof(exe));
      while ( *cmd == ' ' ) cmd++;
      next=::strchr(cmd,' ');
      if ( !next ) next = cmd + strlen(cmd);
      if ( (tmp1=::strchr(cmd,'\"')) > 0 && tmp1 < next )  {
        tmp2 = ::strchr(++tmp1,'\"');
        if ( tmp2 > 0 )   {
          next = ++tmp2;
          if ( cmd < tmp1 ) strncpy(exe, cmd, tmp1-cmd-1);
          strncpy(&exe[strlen(exe)], tmp1, tmp2-tmp1-1);
        }
        else    {
          std::cout << "Mismatched \" in command line arguments" << std::endl;
          s_argvChars.erase(s_argvChars.begin(), s_argvChars.end());
          s_argvStrings.erase(s_argvStrings.begin(), s_argvStrings.end());
          return s_argvStrings;
        }
      }
      else    {
        strncpy(exe, cmd, next-cmd);
      }
      s_argvStrings.push_back(exe);
      s_argvChars.push_back( s_argvStrings.back().c_str());
    }
#elif defined(linux) || defined(__APPLE__)
    sprintf(exe, "/proc/%d/cmdline", ::getpid());
    FILE *cmdLine = ::fopen(exe,"r");
    char cmd[1024];
    if ( cmdLine )   {
      long len = fread(cmd, sizeof(char), sizeof(cmd), cmdLine);
      if ( len > 0 )   {
        cmd[len] = 0;
        for ( char* token = cmd; token-cmd < len; token += strlen(token)+1 )  {
          s_argvStrings.push_back(token);
          s_argvChars.push_back( s_argvStrings.back().c_str());
        }
        s_argvStrings[0] = exeName();
        s_argvChars[0]   = s_argvStrings[0].c_str();
      }
    }
    ::fclose(cmdLine);
#endif
  }
  return s_argvStrings;
}

longlong System::cpuTime	(	TimeType	typ = milliSec,
		InfoType	fetch = Times,
		long	pid = -1
	)

Consumed CPU time of process in milli seconds.

CPU kernel time of process in milli seconds.

Parameters:

	typ	Indicator or the unit the time will be returned.
	fetch	Indicator of the information to be fetched. If Fetch_None, the information will not be updated.
	pid	Process ID of which the information will be returned

Returns:

Requested value in the indicated units.

Definition at line 170 of file Timing.cpp.

                                                               {
  longlong cputime = 0;
  KERNEL_USER_TIMES info;
  if ( fetch != NoFetch && getProcess()->query(pid, fetch, &info) )   {
    cputime = adjustTime(typ, info.KernelTime+info.UserTime );
  }
  return cputime;
}

longlong System::creationTime	(	TimeType	typ = milliSec,
		InfoType	fetch = Times,
		long	pid = -1
	)

Process Creation time.

Units of time between process creation and begin of epoche.

Parameters:

	typ	Indicator or the unit the time will be returned.
	fetch	Indicator of the information to be fetched. If Fetch_None, the information will not be updated.
	pid	Process ID of which the information will be returned

Returns:

Requested value in the indicated units.

Definition at line 116 of file Timing.cpp.

                                                                      {
  longlong created = 0;
  KERNEL_USER_TIMES info;
  if ( fetch != NoFetch && getProcess()->query(pid, fetch, &info) )   {
    created = adjustTime(typ, info.CreateTime-UNIX_BASE_TIME);
  }
  return created;
}

longlong System::currentTime

(

TimeType

typ = milliSec

)

Retrieve absolute system time.

Retrieve current system time.

Parameters:

typ

Indicator or the unit the time will be returned.

Returns:

Requested value in the indicated units.

Definition at line 81 of file Timing.cpp.

                                            {
  longlong current = 0;
#ifdef _WIN32
  ::GetSystemTimeAsFileTime((FILETIME*)&current);
  current -= UNIX_BASE_TIME;
#else
  struct timeval tv;
  struct timezone tz;
  ::gettimeofday(&tv, &tz);
  current  = tv.tv_sec;
  current *= 1000000;
  current += tv.tv_usec;
  current *= 10;
#endif
  return adjustTime(typ, current);
}

longlong System::ellapsedTime	(	TimeType	typ = milliSec,
		InfoType	fetch = Times,
		long	pid = -1
	)

Ellapsed time since start of process in milli seconds.

Parameters:

	typ	Indicator or the unit the time will be returned.
	timevalue	Time value to be converted.

Returns:

Requested value in the indicated units.

Definition at line 141 of file Timing.cpp.

                                                                    {
  KERNEL_USER_TIMES info;
  longlong ellapsed = currentTime(microSec)*10;
  getProcess()->query(pid, fetch, &info);
  ellapsed = adjustTime(typ, ellapsed+UNIX_BASE_TIME-info.CreateTime);
  return ellapsed;
}

System::ImageHandle System::exeHandle

(

)

Handle to the executable file running.

Definition at line 167 of file ModuleInfo.cpp.

                                       {
#ifdef _WIN32
  if ( processHandle() )    {
    static HINSTANCE handle = 0;
    DWORD   cbNeeded;
    if ( 0 == handle && _psApi.isValid() )    {
      if ( _psApi.EnumProcessModules( processHandle(), &handle, sizeof(ModuleHandle), &cbNeeded) )   {
      }
    }
    return handle;
  }
  return 0;
#elif defined(linux) || defined(__APPLE__)
  // This does NOT work!
  static Dl_info infoBuf, *info = &infoBuf;
  if ( 0 == info ) {
    void* handle = ::dlopen(0, RTLD_LAZY);
    //printf("Exe handle:%X\n", handle);
    if ( 0 != handle ) {
      void* func = ::dlsym(handle, "main");
      //printf("Exe:Func handle:%X\n", func);
      if ( 0 != func ) {
        if ( 0 != ::dladdr(func, &infoBuf) ) {
                //std::cout << "All OK" << std::endl;
          info = &infoBuf;
        }
      }
    }
  }
  return info;
#elif __hpux
  // Don't know how to solve this .....
  return 0;
#endif
}

const std::string & System::exeName

(

)

Name of the executable file running.

Definition at line 203 of file ModuleInfo.cpp.

                                    {
  static std::string module("");
  if ( module.length() == 0 )    {
    char name[PATH_MAX] = {"Unknown.module"};
    name[0] = 0;
#ifdef _WIN32
    if ( _psApi.isValid() && processHandle() )   {
      _psApi.GetModuleFileNameExA( processHandle(), (HINSTANCE)exeHandle(), name,sizeof(name) );
    }
#elif defined(linux) || defined(__APPLE__)
    char cmd[512];
    ::sprintf(cmd, "/proc/%d/exe", ::getpid());
    module = "Unknown";
    ::readlink(cmd, name, sizeof(name));
#elif __hpux
    ::realpath(((HMODULE*)exeHandle())->dsc.filename, name);
#endif
    module = name;
  }
  return module;
}

long System::exitStatus	(	InfoType	fetch = ProcessBasics,
		long	pid = -1
	)

Basic Process Information: Exit status (does not really make sense for the running process, but for others!).

Definition at line 82 of file Memory.cpp.

                                                  {
  PROCESS_BASIC_INFORMATION info;
  if ( fetch != NoFetch && getProcess()->query(pid, ProcessBasics, &info) )
    return info.ExitStatus;
  return -2;
}

const std::vector< std::string > System::getEnv

(

)

get all environment variables

get all defined environment vars

Definition at line 673 of file System.cpp.

                                          {
#if defined(_WIN32)
#  define environ _environ
#elif defined(__APPLE__)
  static char **environ = *_NSGetEnviron();
#endif
  std::vector<std::string> vars;
  for (int i=0; environ[i] != 0; ++i) {
    vars.push_back(environ[i]);
  }
  return vars;
}

const std::string System::getEnv

(

const char *

var

)

get a particular environment variable

get a particular env var, return "UNKNOWN" if not defined

Definition at line 659 of file System.cpp.

                                              {
  char* env;
  if  ( (env = getenv(var)) != 0 ) {
    return env;
  } else {
    return "UNKNOWN";
  }
}

const std::string System::getErrorString

(

unsigned long

error

)

Retrieve error code as string for a given error.

Definition at line 253 of file System.cpp.

                                                             {
  std::string errString =  "";
#ifdef _WIN32
  LPVOID lpMessageBuffer;
  ::FormatMessage(
    FORMAT_MESSAGE_ALLOCATE_BUFFER |  FORMAT_MESSAGE_FROM_SYSTEM,
    NULL,
    error,
    MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), //The user default language
    (LPTSTR) &lpMessageBuffer,
    0,
    NULL );
  errString = (const char*)lpMessageBuffer;
  // Free the buffer allocated by the system
  ::LocalFree( lpMessageBuffer );
#else
  char *cerrString(0);
  // Remember: for linux dl* routines must be handled differently!
  if ( error == 0xAFFEDEAD ) {
    cerrString = (char*)::dlerror();
    if ( 0 == cerrString ) {
      cerrString = ::strerror(error);
    }
    if ( 0 == cerrString ) {
      cerrString = (char *)"Unknown error. No information found in strerror()!";
    }
    else {
      errString = std::string(cerrString);
    }
    errno = 0;
  }
  else    {
    cerrString = ::strerror(error);
    errString = std::string(cerrString);
  }
#endif
  return errString;
}

unsigned long System::getLastError

(

)

Get last system known error.

Retrieve last error code.

Definition at line 237 of file System.cpp.

                                      {
#ifdef _WIN32
  return ::GetLastError();
#else
  // convert errno (int) to unsigned long
  return static_cast<unsigned long>(static_cast<unsigned int>(errno));
#endif
}

const std::string System::getLastErrorString

(

)

Get last system error as string.

Retrieve last error code as string.

Definition at line 247 of file System.cpp.

                                              {
  const std::string errString = getErrorString(getLastError());
  return errString;
}

unsigned long System::getProcedureByName	(	ImageHandle	handle,
		const std::string &	name,
		Creator *	pFunction
	)

Get a specific function defined in the DLL.

Definition at line 232 of file System.cpp.

                                                                                                         {
  return getProcedureByName(handle, name, (EntryPoint*)pFunction);
}

unsigned long System::getProcedureByName	(	ImageHandle	handle,
		const std::string &	name,
		EntryPoint *	pFunction
	)

Get a specific function defined in the DLL.

Definition at line 182 of file System.cpp.

                                                                                                            {
#ifdef _WIN32
  *pFunction = (EntryPoint)::GetProcAddress((HINSTANCE)handle, name.data());
  if ( 0 == *pFunction )    {
    return System::getLastError();
  }
  return 1;
#elif defined(linux)
#if __GNUC__ < 4
  *pFunction = (EntryPoint)::dlsym(handle, name.c_str());
#else
  *pFunction = FuncPtrCast<EntryPoint>(::dlsym(handle, name.c_str()));
#endif
  if ( 0 == *pFunction )    {
    errno = 0xAFFEDEAD;
   // std::cout << "System::getProcedureByName>" << getLastErrorString() << std::endl;
    return 0;
  }
  return 1;
#elif defined(__APPLE__)
  *pFunction = (EntryPoint)::dlsym(handle, name.c_str());
  if(!(*pFunction)) {
    // Try with an underscore :
    std::string sname = "_" + name;
    *pFunction = (EntryPoint)::dlsym(handle, sname.c_str());
  }
  if ( 0 == *pFunction )    {
    errno = 0xAFFEDEAD;
    std::cout << "System::getProcedureByName>" << getLastErrorString() << std::endl;
    //std::cout << "System::getProcedureByName> failure" << std::endl;
    return 0;
  }
  return 1;
#elif __hpux
  HMODULE* mod = (HMODULE*)handle;
  if ( 0 != mod ) {
    long ll1 = name.length();
    for ( int i = 0; i < mod->numSym; i++ ) {
      long ll2 = strlen(mod->sym[i].name);
      if ( 0 != ::strncmp(mod->sym[i].name, name.c_str(), (ll1>ll2) ? ll1 : ll2)==0 ) {
              *pFunction = (EntryPoint) mod->sym[i].value;
              return 1;
      }
    }
  }
  return 0;
#endif
}

ProcessDescriptor * System::getProcess

(

)

Retrieve Process structure.

Definition at line 213 of file ProcessDescriptor.cpp.

                                              {
  static ProcessDescriptor p;
#ifdef _WIN32
  static bool first = true;
  if ( first )    {
    first = false;
    void* mh = ::LoadLibrary("NTDll.dll");
    if ( mh )  {
      NtApi::NtQueryInformationProcess = (NtApi::__NtQueryInformationProcess)
        ::GetProcAddress((HINSTANCE)mh, "NtQueryInformationProcess");
    }
  }
#endif
  return &p;
}

bool System::getStackLevel	(	void *addresses	__attribute__(unused),
		void *&addr	__attribute__(unused),
		std::string &fnc	__attribute__(unused),
		std::string &lib	__attribute__(unused)
	)

Definition at line 743 of file System.cpp.

{

#ifdef __linux

  Dl_info info;

  if ( dladdr( addresses, &info ) && info.dli_fname
      && info.dli_fname[0] != '\0' ) {
    const char* symbol = info.dli_sname
    && info.dli_sname[0] != '\0' ? info.dli_sname : 0;

    lib = info.dli_fname;
    addr = info.dli_saddr;
    const char* dmg(0);

    if (symbol != 0) {
      int stat;
      dmg = abi::__cxa_demangle(symbol,0,0,&stat);
      fnc = (stat == 0) ? dmg : symbol;
    } else {
      fnc = "local";
    }
    free((void*)dmg);
    return true ;
  } else {
    return false ;
  }

#else // not implemented for windows and osx
  return false ;
#endif

}

GAUDI_API bool System::getStackLevel	(	void *	addresses,
		void *&	addr,
		std::string &	fnc,
		std::string &	lib
	)

std::string System::homeDirectory

(

)

Definition at line 58 of file Environment.cpp.

                                 {
   // Return the user's home directory.
  std::string home_dir = "./";
  const char *h = 0;
  if ( 0 == (h = ::getenv("home")))  {
    h = ::getenv("HOME");
  }
  if ( h ) {
    home_dir = h;
  }
  else {
    // for Windows NT HOME might be defined as either $(HOMESHARE)/$(HOMEPATH)
    //                                         or     $(HOMEDRIVE)/$(HOMEPATH)
    h = ::getenv("HOMESHARE");
    if ( 0 == h )  {
      h = ::getenv("HOMEDRIVE");
    }
    if (h) {
      home_dir = h;
      h = ::getenv("HOMEPATH");
      if( h )  {
        home_dir += h;
      }
    }
  }
  return home_dir;
}

const std::string & System::hostName

(

)

Host name.

Definition at line 489 of file System.cpp.

                                  {
  static std::string host = "";
  if ( host == "" ) {
    char buffer[512];
    memset(buffer,0,sizeof(buffer));
#ifdef _WIN32
    unsigned long len = sizeof(buffer);
    ::GetComputerName(buffer, &len);
#else
    ::gethostname(buffer, sizeof(buffer));
#endif
    host = buffer;
  }
  return host;
}

longlong System::kernelTime	(	TimeType	typ = milliSec,
		InfoType	fetch = Times,
		long	pid = -1
	)

CPU kernel mode time of process in milli seconds.

CPU kernel time of process in milli seconds.

Parameters:

	typ	Indicator or the unit the time will be returned.
	fetch	Indicator of the information to be fetched. If Fetch_None, the information will not be updated.
	pid	Process ID of which the information will be returned

Returns:

Requested value in the indicated units.

Definition at line 150 of file Timing.cpp.

                                                                  {
  KERNEL_USER_TIMES info;
  longlong kerneltime = 0;
  if ( fetch != NoFetch && getProcess()->query(pid, fetch, &info) )   {
    kerneltime = adjustTime(typ, info.KernelTime );
  }
  return kerneltime;
}

const std::vector< std::string > System::linkedModules

(

)

Vector of names of linked modules.

Definition at line 225 of file ModuleInfo.cpp.

                                                    {
  if ( s_linkedModules.size() == 0 )    {
#ifdef _WIN32
    char   name[255];  // Maximum file name length on NT 4.0
    DWORD  cbNeeded;
    HINSTANCE handle[1024];
    if ( _psApi.isValid() )    {
      if ( _psApi.EnumProcessModules(processHandle(),handle,sizeof(handle),&cbNeeded) )   {
        for (size_t i = 0; i < cbNeeded/sizeof(HANDLE); i++ )    {
          if ( 0 < _psApi.GetModuleFileNameExA( processHandle(), handle[i], name, sizeof(name)) )   {
            s_linkedModules.push_back(name);
          }
        }
      }
    }
#elif defined(linux) || defined(__APPLE__)
    char ff[512], cmd[1024], fname[1024], buf1[64], buf2[64], buf3[64], buf4[64];
    ::sprintf(ff, "/proc/%d/maps", ::getpid());
    FILE* maps = ::fopen(ff, "r");
    while( ::fgets(cmd, sizeof(cmd), maps) ) {
      int len;
      sscanf(cmd, "%s %s %s %s %d %s", buf1, buf2, buf3, buf4, &len, fname);
      if ( len > 0 && strncmp(buf2,"r-xp",strlen("r-xp")) == 0 ) {
        s_linkedModules.push_back(fname);
      }
    }
    ::fclose(maps);
#endif
  }
  return s_linkedModules;
}

unsigned long System::loadDynamicLib	(	const std::string &	name,
		ImageHandle *	handle
	)

Load dynamic link library.

Definition at line 123 of file System.cpp.

                                                                               {
  unsigned long res;
  // if name is empty, just load it
  if (name.length() == 0) {
    res = loadWithoutEnvironment(name, handle);
  } else {
    // If the name is a logical name (environment variable), the try
    // to load the corresponding library from there.
    std::string env = name;
    if ( 0 != ::getenv(env.c_str()) )    {
      std::string imgName = ::getenv(env.c_str());
      res = loadWithoutEnvironment(imgName, handle);
    } else {
      // build the dll name
      std::string dllName = name;
#if defined(linux) || defined(__APPLE__)
      dllName = "lib" + dllName;
#endif
      dllName += SHLIB_SUFFIX;
      // try to locate the dll using the standard PATH
      res = loadWithoutEnvironment(dllName, handle);
    }
    if ( res != 1 ) {
#if defined(linux) || defined(__APPLE__)
      errno = 0xAFFEDEAD;
#endif
     // std::cout << "System::loadDynamicLib>" << getLastErrorString() << std::endl;
    }
  }
  return res;
}

const std::string & System::machineType

(

)

Machine type.

Definition at line 544 of file System.cpp.

                                     {
  static std::string mach = "";
#ifdef _WIN32
  SYSTEM_INFO ut;
  ::GetSystemInfo(&ut);
  char arch[64];
  sprintf(arch,"%d",ut.wProcessorArchitecture);
  mach =  arch;
#else
  struct utsname ut;
  if (uname(&ut) == 0) {
    mach = ut.machine;
  } else {
    mach = "UNKNOWN";
  }
#endif
  return mach;
}

long System::mappedMemory	(	MemoryUnit	unit = kByte,
		InfoType	fetch = Memory,
		long	pid = -1
	)

Basic Process Information: priority boost.

Definition at line 181 of file Memory.cpp.

                                                                     {
  VM_COUNTERS info;
  if ( fetch != NoFetch && getProcess()->query(pid, fetch, &info) )
    return adjustMemory(unit, info.WorkingSetSize);
  return -2;
}

long System::mappedMemoryPeak	(	MemoryUnit	unit = kByte,
		InfoType	fetch = Memory,
		long	pid = -1
	)

Basic Process Information: priority boost.

Definition at line 189 of file Memory.cpp.

                                                                         {
  VM_COUNTERS info;
  if ( fetch != NoFetch && getProcess()->query(pid, fetch, &info) )
    return adjustMemory(unit, info.PeakWorkingSetSize);
  return -2;
}

long System::maxMemoryLimit	(	MemoryUnit	unit = kByte,
		InfoType	fetch = Quota,
		long	pid = -1
	)

System Process Limits: Maximum amount of virtual memory this process is allowed to use.

Definition at line 205 of file Memory.cpp.

                                                                       {
  QUOTA_LIMITS quota;
  if ( fetch != NoFetch && getProcess()->query(pid, fetch, &quota) )
    return adjustMemory(unit, quota.MaximumWorkingSetSize);
  return 0;
}

long System::minMemoryLimit	(	MemoryUnit	unit = kByte,
		InfoType	fetch = Quota,
		long	pid = -1
	)

System Process Limits: Minimum amount of virtual memory this process may use.

Definition at line 197 of file Memory.cpp.

                                                                       {
  QUOTA_LIMITS quota;
  if ( fetch != NoFetch && getProcess()->query(pid, fetch, &quota) )
    return adjustMemory(unit, quota.MinimumWorkingSetSize);
  return 0;
}

System::ImageHandle System::moduleHandle

(

)

Handle to currently executed module.

Definition at line 136 of file ModuleInfo.cpp.

                                          {
  if ( 0 == ModuleHandle )    {
    if ( processHandle() )    {
#ifdef _WIN32
      static HINSTANCE handle = 0;
      DWORD   cbNeeded;
      if ( 0 == handle && _psApi.isValid() )    {
        if ( _psApi.EnumProcessModules( processHandle(), &handle, sizeof(ModuleHandle), &cbNeeded) )   {
        }
      }
      return handle;
#elif defined(linux) || defined(__APPLE__)
      static Dl_info info;
      if ( 0 !=
           ::dladdr(
#if __GNUC__ < 4
               (void*)System::moduleHandle
#else
               FuncPtrCast<void*>(System::moduleHandle)
#endif
               , &info) ) {
        return &info;
      }
#elif __hpux
      return 0;  // Don't know how to solve this .....
#endif
    }
  }
  return ModuleHandle;
}

const std::string & System::moduleName

(

)

Get the name of the (executable/DLL) file without file-type.

Retrieve base name of module.

Definition at line 55 of file ModuleInfo.cpp.

                                      {
  static std::string module("");
  if ( module == "" )   {
    if ( processHandle() && moduleHandle() )    {
#ifdef _WIN32
      char moduleName[256] = {"Unknown.module"};
      moduleName[0] = 0;
      if ( _psApi.isValid() )   {
        _psApi.GetModuleBaseNameA( processHandle(), (HINSTANCE)moduleHandle(), moduleName, sizeof(moduleName) );
      }
      std::string mod = moduleName;
#elif defined(linux) || defined(__APPLE__)
      std::string mod = ::basename((char*)((Dl_info*)moduleHandle())->dli_fname);
#elif __hpux
      std::string mod = ::basename(((HMODULE*)moduleHandle())->dsc.filename);
#endif
      module = mod.substr(0, mod.rfind('.'));
    }
  }
  return module;
}

const std::string & System::moduleNameFull

(

)

Get the full name of the (executable/DLL) file.

Retrieve full name of module.

Definition at line 78 of file ModuleInfo.cpp.

                                          {
  static std::string module("");
  if ( module == "" )   {
    if ( processHandle() && moduleHandle() )    {
      char name[PATH_MAX] = {"Unknown.module"};
      name[0] = 0;
#ifdef _WIN32
      if ( _psApi.isValid() )   {
        _psApi.GetModuleFileNameExA( processHandle(), (HINSTANCE)moduleHandle(), name,sizeof(name) );
      }
#elif defined(linux) || defined(__APPLE__)
      ::realpath(((Dl_info*)moduleHandle())->dli_fname, name);
#elif __hpux
      ::realpath(((HMODULE*)moduleHandle())->dsc.filename, name);
#endif
      module = name;
    }
  }
  return module;
}

System::ModuleType System::moduleType

(

)

Get type of the module.

Definition at line 100 of file ModuleInfo.cpp.

                                      {
  static ModuleType type = UNKNOWN;
  if ( type == UNKNOWN )    {
    const std::string& module = moduleNameFull();
    int loc = module.rfind('.')+1;
    if ( loc == 0 )
      type = EXECUTABLE;
    else if ( module[loc] == 'e' || module[loc] == 'E' )
      type = EXECUTABLE;
#ifdef _WIN32
    else if ( module[loc] == 'd' || module[loc] == 'D' )
#else
    else if ( module[loc] == 's' && module[loc+1] == 'o' )
#endif
      type = SHAREDLIB;
    else
      type = UNKNOWN;
  }
  return type;
}

long System::nonPagedMemory	(	MemoryUnit	unit = kByte,
		InfoType	fetch = Memory,
		long	pid = -1
	)

Basic Process Information: Current usage of non paged memory.

Basic Process Information: priority boost.

Definition at line 106 of file Memory.cpp.

                                                                       {
  VM_COUNTERS info;
  if ( fetch != NoFetch && getProcess()->query(pid, fetch, &info) )
    return adjustMemory(unit, info.QuotaNonPagedPoolUsage);
  return -2;
}

long System::nonPagedMemoryLimit	(	MemoryUnit	unit = kByte,
		InfoType	fetch = Quota,
		long	pid = -1
	)

System Process Limits: Maximum amount of non-paged memory this process is allowed to use.

Definition at line 114 of file Memory.cpp.

                                                                            {
  POOLED_USAGE_AND_LIMITS quota;
  if ( fetch != NoFetch && getProcess()->query(pid, fetch, &quota) )
    return adjustMemory(unit, quota.NonPagedPoolLimit);
  return 0;
}

long System::nonPagedMemoryPeak	(	MemoryUnit	unit = kByte,
		InfoType	fetch = Memory,
		long	pid = -1
	)

Basic Process Information: Peak usage of non paged memory.

Basic Process Information: priority boost.

Definition at line 98 of file Memory.cpp.

                                                                           {
  VM_COUNTERS info;
  if ( fetch != NoFetch && getProcess()->query(pid, fetch, &info) )
    return adjustMemory(unit, info.QuotaPeakNonPagedPoolUsage);
  return -2;
}

long System::numCmdLineArgs

(

)

Number of arguments passed to the commandline.

Definition at line 583 of file System.cpp.

                              {
  return cmdLineArgs().size();
}

long System::numPageFault	(	InfoType	fetch = Memory,
		long	pid = -1
	)

Basic Process Information: Number of page faults.

Basic Process Information: priority boost.

Definition at line 146 of file Memory.cpp.

                                                    {
  VM_COUNTERS info;
  if ( fetch != NoFetch && getProcess()->query(pid, fetch, &info) )
    return info.PageFaultCount;
  return -2;
}

const std::string & System::osName

(

)

OS name.

Definition at line 506 of file System.cpp.

                                {
  static std::string osname = "";
#ifdef _WIN32
  osname = "Windows";
#else
  struct utsname ut;
  if (uname(&ut) == 0) {
    osname = ut.sysname;
  } else {
    osname = "UNKNOWN";
  }
#endif
  return osname;
}

const std::string & System::osVersion

(

)

OS version.

Definition at line 523 of file System.cpp.

                                   {
  static std::string osver = "";
#ifdef _WIN32
  OSVERSIONINFO ut;
  ut.dwOSVersionInfoSize = sizeof(OSVERSIONINFO);
  ::GetVersionEx(&ut);
  char ver[64];
  sprintf(ver,"%d.%d",ut.dwMajorVersion,ut.dwMinorVersion);
  osver = ver;
#else
  struct utsname ut;
  if (uname(&ut) == 0) {
    osver = ut.release;
  } else {
    osver = "UNKNOWN";
  }
#endif
  return osver;
}

long System::pagedMemory	(	MemoryUnit	unit = kByte,
		InfoType	fetch = Memory,
		long	pid = -1
	)

Basic Process Information: Amount of paged memory currently occupied by the process 'pid'.

Definition at line 122 of file Memory.cpp.

                                                                    {
  VM_COUNTERS info;
  if ( fetch != NoFetch && getProcess()->query(pid, fetch, &info) )
    return adjustMemory(unit, info.QuotaPagedPoolUsage);
  return -2;
}

long System::pagedMemoryLimit	(	MemoryUnit	unit = kByte,
		InfoType	fetch = Quota,
		long	pid = -1
	)

Basic Process Information: Amount of paged memory that can be occupied by the process 'pid'.

Definition at line 138 of file Memory.cpp.

                                                                         {
  POOLED_USAGE_AND_LIMITS quota;
  if ( fetch != NoFetch && getProcess()->query(pid, fetch, &quota) )
    return adjustMemory(unit, quota.PagedPoolLimit);
  return 0;
}

long System::pagedMemoryPeak	(	MemoryUnit	unit = kByte,
		InfoType	fetch = Memory,
		long	pid = -1
	)

Basic Process Information: Maximum of paged memory occupied by the process 'pid'.

Definition at line 130 of file Memory.cpp.

                                                                        {
  VM_COUNTERS info;
  if ( fetch != NoFetch && getProcess()->query(pid, fetch, &info) )
    return adjustMemory(unit, info.QuotaPeakPagedPoolUsage);
  return -2;
}

long System::pagefileUsage	(	MemoryUnit	unit = kByte,
		InfoType	fetch = Memory,
		long	pid = -1
	)

Basic Process Information: Current page file usage.

Basic Process Information: priority boost.

Definition at line 154 of file Memory.cpp.

                                                                      {
  VM_COUNTERS info;
  if ( fetch != NoFetch && getProcess()->query(pid, fetch, &info) )
    return adjustMemory(unit, info.PagefileUsage);
  return -2;
}

long System::pagefileUsageLimit	(	MemoryUnit	unit = kByte,
		InfoType	fetch = Quota,
		long	pid = -1
	)

Basic Process Information: Peak usage of page file.

Basic Process Information: priority boost.

Definition at line 170 of file Memory.cpp.

                                                                           {
  POOLED_USAGE_AND_LIMITS quota;
  if ( fetch != NoFetch && getProcess()->query(pid, fetch, &quota) )    {
    if ( long(quota.PagefileLimit) < 0 )
      return -1;//LONG_MAX;
    return adjustMemory(unit, quota.PagefileLimit);
  }
  return -2;
}

long System::pagefileUsagePeak	(	MemoryUnit	unit = kByte,
		InfoType	fetch = Memory,
		long	pid = -1
	)

Basic Process Information: Peak usage of page file.

Basic Process Information: priority boost.

Definition at line 162 of file Memory.cpp.

                                                                          {
  VM_COUNTERS info;
  if ( fetch != NoFetch && getProcess()->query(pid, fetch, &info) )
    return adjustMemory(unit, info.PeakPagefileUsage);
  return -2;
}

long System::parentID	(	InfoType	fetch = ProcessBasics,
		long	pid = -1
	)

Basic Process Information: Parent's process ID.

Definition at line 66 of file Memory.cpp.

                                                {
  PROCESS_BASIC_INFORMATION info;
  if ( fetch != NoFetch && getProcess()->query(pid, ProcessBasics, &info) )
    return info.InheritedFromUniqueProcessId;
  return 0;
}

PathResolver::SearchPathStatus System::PathResolverCheckSearchPath

(

const std::string &

search_path

)

Definition at line 597 of file PathResolver.cpp.

{
  return PathResolver::check_search_path (search_path);
}

std::string System::PathResolverFindDataFile

(

const std::string &

logical_file_name

)

Definition at line 631 of file PathResolver.cpp.

{
  return PathResolver::find_file (logical_file_name, "DATAPATH");
}

std::string System::PathResolverFindDirectory	(	const std::string &	logical_file_name,
		const std::string &	search_path
	)

Definition at line 602 of file PathResolver.cpp.

{
  return PathResolver::find_directory (logical_file_name, search_path);
}

std::string System::PathResolverFindDirectoryFromList	(	const std::string &	logical_file_name,
		const std::string &	search_list
	)

Definition at line 608 of file PathResolver.cpp.

{
  return PathResolver::find_directory_from_list (logical_file_name, search_list);
}

std::string System::PathResolverFindFile	(	const std::string &	logical_file_name,
		const std::string &	search_path
	)

Definition at line 614 of file PathResolver.cpp.

{
  return PathResolver::find_file (logical_file_name, search_path);
}

std::string System::PathResolverFindFileFromList	(	const std::string &	logical_file_name,
		const std::string &	search_list
	)

Definition at line 620 of file PathResolver.cpp.

{
  return PathResolver::find_file_from_list (logical_file_name, search_list);
}

std::string System::PathResolverFindXMLFile

(

const std::string &

logical_file_name

)

Definition at line 626 of file PathResolver.cpp.

{
  return PathResolver::find_file (logical_file_name, "XMLPATH");
}

static bool System::PR_absolute_path

(

const std::string &

name

)

[static]

Definition at line 116 of file PathResolver.cpp.

{
  if (name.size () == 0) return (false);

  if ((name[0] == '/') ||
      (name[0] == '\\')) return (true);

  if (name.size () >= 2)
    {
      if (name[1] == ':')
        {
          return (true);
        }
    }
  return (false);
}

static void System::PR_basename	(	const std::string &	file_name,
		std::string &	result
	)			[static]

Definition at line 133 of file PathResolver.cpp.

{
  std::string::size_type pos = file_name.find_last_of ('/');

  if (pos == std::string::npos)
    {
      pos = file_name.find_last_of ('\\');
    }

  if (pos == std::string::npos)
    {
      result = file_name;
    }
  else
    {
      result = file_name.substr (pos + 1);
    }
}

static void System::PR_compress_path

(

std::string &

dir

)

[static]

Definition at line 34 of file PathResolver.cpp.

{
#ifdef _WIN32
  static const char pattern[] = "\\..\\";
#else
  static const char pattern[] = "/../";
#endif

#ifdef _WIN32
  static const char file_separator = '\\';
  static const char double_file_separator[] = "\\\\";
#else
  static const char file_separator = '/';
  static const char double_file_separator[] = "//";
#endif

  if (dir.size () == 0) return;

    //
    // We first synchronize to using file_separator() in any case.
    //

  for (;;)
    {
      std::string::size_type pos;
      pos = dir.find (double_file_separator);
      if (pos == std::string::npos) break;
      dir.erase (pos, 1);
    }

  for (;;)
    {
      std::string::size_type pos1;
      std::string::size_type pos2;

      pos1 = dir.find (pattern);
      if (pos1 == std::string::npos) break;

        //
        // extract "aaaa/xxxx" from "aaaa/xxxx/../bbbb"
        //
      std::string p = dir.substr (0, pos1);
      
        //
        // Is "aaaa/xxxx" only made of "xxxx" ?
        // 
      pos2 = p.find_last_of (file_separator);
      
      if (pos2 == std::string::npos) break;
      
        //    01234567890123456
        //    aaaa/xxxx/../bbbb
        //        2    1   3
        //
        // erase the "/xxxx/../" pattern
        // result will be "aaaa/bbbb"
        //
      dir.erase (pos2, pos1 + 4 - pos2 - 1);
    }

    //if (dir[dir.size () - 1] == file_separator ()) dir.erase (dir.size () - 1);
}

static void System::PR_dirname	(	const std::string &	file_name,
		std::string &	result
	)			[static]

Definition at line 97 of file PathResolver.cpp.

{
  std::string::size_type pos = file_name.find_last_of ('/');
  if (pos == std::string::npos)
    {
      pos = file_name.find_last_of ('\\');
    }

  if (pos == std::string::npos)
    {
      result = "";
    }
  else
    {
      result = file_name;
      result.erase (pos);
    }
}

static bool System::PR_find	(	const std::string &	search_base,
		const std::string &	logical_file_prefix,
		const std::string &	logical_file_name,
		PR_file_type	file_type,
		PathResolver::SearchType	search_type,
		std::string &	result
	)			[static]

Definition at line 321 of file PathResolver.cpp.

{
  static int level = 0;

#ifdef _WIN32
  static const char file_separator = '\\';
#else
  static const char file_separator = '/';
#endif

  std::string file_path = "";
  std::string real_name = "";

  //PR_indent (level); std::cout << "PR_find> sb=" << search_base << " lfp=" << logical_file_prefix << " lfn=" << logical_file_name << std::endl;

  if (search_base != "")
    {
      file_path = search_base;
      file_path += file_separator;
    }
  else
    {
      file_path = "";
    }

  file_path += logical_file_name;

  //PR_indent (level); std::cout << "PR_find> test1 file_path=" << file_path << std::endl;

  result = file_path;
  bool found = PR_test_exist (file_path, result, file_type);

  if (!found && (logical_file_prefix != ""))
    {
      if (search_base != "")
        {
          file_path = search_base;
          file_path += file_separator;
        }
      else
        {
          file_path = "";
        }

      file_path += logical_file_prefix;
      file_path += file_separator;
      file_path += logical_file_name;

      //PR_indent (level); std::cout << "PR_find> test2 file_path=" << file_path << std::endl;

      result = file_path;
      found = PR_test_exist (file_path, result, file_type);
    }

  //PR_indent (level); std::cout << "PR_find> test3 found=" << found << " search_type=" << search_type << std::endl;

  if (!found && (search_type == PathResolver::RecursiveSearch))
    {
      std::string dir_name = "";
      std::string file_name = "";
      std::vector<std::string> list;

      PR_scan_dir (search_base, list);

      std::vector<std::string>::iterator it;

      for (it = list.begin (); it != list.end (); ++it)
        {
          const std::string& d = *it;

          if (PR_test_exist (d, file_path, PR_directory))
            {
              //PR_indent (level); std::cout << "d=" << d << std::endl;

              level++;
              bool s = PR_find (d, logical_file_prefix, logical_file_name, file_type, search_type, result);
              level--;

              if (s)
                {
                  //PR_indent (level); std::cout << "PR_find> result=" << result << std::endl;
                  found = true;
                  break;
                }
            }
        }
    }

  return (found);
}

static bool System::PR_find_from_list	(	const std::string &	logical_file_name,
		const std::string &	search_list,
		PR_file_type	file_type,
		PathResolver::SearchType	search_type,
		std::string &	result
	)			[static]

Definition at line 417 of file PathResolver.cpp.

{
#ifdef _WIN32
  static const char path_separator = ';';
#else
  static const char path_separator = ':';
#endif

  std::string::size_type pos = 0;

  std::string file_name = "";
  std::string file_prefix = "";

  PR_basename (logical_file_name, file_name);
  PR_dirname (logical_file_name, file_prefix);

  //consider relative paths to be part of file_name
  if (!file_prefix.empty() && file_prefix[0]!='/') {
    file_name = file_prefix + '/' + file_name;
    file_prefix="";
  }

  std::string real_name = "";

  bool found = false;

  if (PR_find ("", file_prefix, file_name, file_type, search_type, result))
    {
      found = true;
    }

  if (!found)
    {
      for (int i = 0;;i++)
        {
          bool ending = false;

          std::string::size_type next = search_list.find (path_separator, pos);

          std::string path = search_list.substr (pos, next - pos);

          if (next == std::string::npos)
            {
              path = search_list.substr (pos);
              ending = true;
            }
          else
            {
              path = search_list.substr (pos, next - pos);
              pos = next + 1;
            }
          
          //std::cout << "path[" << i << "]=" << path << std::endl;
          
          if (PR_find (path, file_prefix, file_name, file_type, search_type, result))
            {
              found = true;
              break;
            }
          
          if (ending) break;
        }
    }

  return (found);
}

static void System::PR_scan_dir	(	const std::string &	dir_name,
		std::vector< std::string > &	list
	)			[static]

Definition at line 213 of file PathResolver.cpp.

{
#ifdef _WIN32
  static const char file_separator = '\\';
#else
  static const char file_separator = '/';
#endif

  static std::string dir_prefix;
  static std::string name_prefix;
  static std::string real_name;

  dir_prefix = dir_name;
  if (dir_name == "") dir_prefix = ".";

  //std::cout << "PR_scan_dir1> dir_name=" << dir_name << " dir_prefix=" << dir_prefix << std::endl;

  if (!PR_test_exist (dir_prefix, real_name, PR_directory)) {
    PR_dirname (dir_prefix, dir_prefix);
    PR_basename (dir_name, name_prefix);
  }

  bool need_filter = false;

  std::string::size_type wild_card;

  wild_card = name_prefix.find ('*');
  if (wild_card != std::string::npos) {
    name_prefix.erase (wild_card);

    if (name_prefix.size () > 0) {
      need_filter = true;
    }
  }

  list.clear();

#ifdef _WIN32

  long dir;
  struct _finddata_t entry;

  static std::string search;

  search = dir_prefix;
  search += file_separator;
  search += "*";

  dir = _findfirst (search.c_str (), &entry);
  if (dir > 0) {
    for (;;)   {
      if ((strcmp ((char*) entry.name, ".") != 0) &&
          (strcmp ((char*) entry.name, "..") != 0) &&
          (strncmp ((char*) entry.name, ".nfs", 4) != 0)) {
        const char* name = entry.name;

        if (need_filter && 
          (strncmp (name, name_prefix.c_str (), name_prefix.size ()) == 0)) continue;
        std::string name_entry;
        name_entry = dir_prefix;
        name_entry += file_separator;
        name_entry += name;

        list.push_back (name_entry);
      }

      int status = _findnext (dir, &entry);
      if (status != 0) {
        break;
      }
    }
    _findclose (dir);
  }
#else

  DIR* dir = opendir (dir_prefix.c_str ());

  struct dirent* entry;

  if (dir != 0) {
    while ((entry = readdir (dir)) != 0) {
      //if (entry->d_name[0] == '.') continue;
      if (!strcmp ((char*) entry->d_name, ".")) continue;
      if (!strcmp ((char*) entry->d_name, "..")) continue;
      if (!strncmp ((char*) entry->d_name, ".nfs", 4)) continue;

      const char* name = entry->d_name;

      //std::cout << "scan_dir4> name=" << name << std::endl;

      if (need_filter &&
          (strncmp (name, name_prefix.c_str (), name_prefix.size ()) != 0)) continue;

      std::string name_entry;

      name_entry = dir_prefix;
      name_entry += file_separator;
      name_entry += name;

      list.push_back (name_entry);
    }
    closedir (dir);
  }
#endif
}

static bool System::PR_test_exist	(	const std::string &	name,
		std::string &	real_name,
		PR_file_type	file_type
	)			[static]

Definition at line 152 of file PathResolver.cpp.

{
  struct stat file_stat;
  int status;

  char buf[1024];
  strcpy (buf, name.c_str ());

#ifdef _WIN32
  static const char file_separator = '\\';
#else
  static const char file_separator = '/';
#endif

  real_name = name;
#ifndef _WIN32
  for (;;) {
    status = lstat (buf, &file_stat);
    if (status == 0) {
          if (S_ISLNK (file_stat.st_mode) != 0) {
            //std::cout << "#1 " << buf << " stat=" << std::oct << file_stat.st_mode << std::dec << std::endl;
            int n = readlink (buf, buf, sizeof (buf));
            if (n >= 0) buf[n] = 0;
            //std::cout << "test_exist> buf=" << buf << std::endl;
            if (PR_absolute_path (buf)) { 
          real_name = buf;
        }
            else {
          PR_dirname (real_name, real_name);
          real_name += file_separator;
          real_name += buf;
          PR_compress_path (real_name);
          strcpy (buf, real_name.c_str ());
        }
            //std::cout << "#2 " << real_name << std::endl;
            //break;
      }
      else { 
        break;
      }
    }
    else {
      break;
    }
  }
#endif
  status = stat (name.c_str (), &file_stat);

  if (status == 0) {
    if ((file_stat.st_mode & S_IFDIR) == 0) {
      return (file_type == PR_regular_file);
    }
    else {
      return (file_type == PR_directory);
    }
  }
  else {
    return (false);
  }
}

long System::priorityBoost	(	InfoType	fetch = PriorityBoost,
		long	pid = -1
	)

Basic Process Information: priority boost.

Definition at line 90 of file Memory.cpp.

                                                     {
  long info;
  if ( fetch != NoFetch && getProcess()->query(pid, fetch, &info) )
    return info;
  return -2;
}

void * System::processHandle

(

)

Handle to running process.

Retrieve processhandle.

Definition at line 122 of file ModuleInfo.cpp.

                              {
  static long pid = ::getpid();
#ifdef _WIN32
  static HANDLE hP = ::OpenProcess(PROCESS_QUERY_INFORMATION|PROCESS_VM_READ,FALSE,pid);
#else
  static void* hP = (void*)pid;
#endif
  return hP;
}

long System::procID

(

)

Basic Process Information: Process ID.

Definition at line 60 of file Memory.cpp.

                      {
  static long s_pid = ::getpid();
  return s_pid;
}

longlong System::remainingTime	(	TimeType	typ = milliSec,
		InfoType	fetch = Quota,
		long	pid = -1
	)

Maximum processing time left for this process.

System Process Limits: Maximum processing time left for this process.

Parameters:

	typ	Indicator or the unit the time will be returned.
	fetch	Indicator of the information to be fetched. If Fetch_None, the information will not be updated.
	pid	Process ID of which the information will be returned

Returns:

Requested value in the indicated units.

Definition at line 126 of file Timing.cpp.

                                                                       {
  longlong left = 0;
  QUOTA_LIMITS quota;
  if ( fetch != NoFetch && getProcess()->query(pid, fetch, &quota) )   {
    if ( left == -1 )     {
      //left = _I64_MAX;
    }
    else  {
      left = adjustTime(typ, quota.TimeLimit);
    }
  }
  return left;
}

StatusCode System::resolveEnv	(	const std::string &	var,
		std::string &	res,
		int	recusions = 124
	)

Definition at line 49 of file Environment.cpp.

                                                                                   {
  std::string source = var;
  res = i_resolve(source, recursions);
  if ( res.find("${") == std::string::npos ) {
    return StatusCode::SUCCESS;
  }
  return StatusCode::FAILURE;
}

int System::setEnv	(	const std::string &	name,
		const std::string &	value,
		int	overwrite = 1
	)

Set an environment variables.

set an environment variables.

If value is empty, the variable is removed from the environment. When overwrite is 0, the variable is not set if already present. Returns 0 on success, -1 on failure. See man 3 setenv.

Returns:

0 if successful, -1 if not

Definition at line 782 of file System.cpp.

{
#ifndef WIN32
  // UNIX version
  return value.empty() ?
    // remove if set to nothing (and return success)
    ::unsetenv(name.c_str()) , 0 :
    // set the value
    ::setenv(name.c_str(),value.c_str(), overwrite);
#else
  // Windows version
  if ( value.empty() ) {
    // equivalent to unsetenv
    return ::_putenv((name+"=").c_str());
  }
  else {
    if ( !getenv(name.c_str()) || overwrite ) {
      // set if not yet present or overwrite is set (force)
      return ::_putenv((name+"="+value).c_str());
    }
  }
  return 0; // if we get here, we are trying to set a variable already set, but
            // not to overwrite.
            // It is considered a success on Linux (man P setenv)
#endif

}

void System::setModuleHandle

(

System::ImageHandle

handle

)

Attach module handle.

Definition at line 132 of file ModuleInfo.cpp.

                                                        {
  ModuleHandle = handle;
}

longlong System::systemStart

(

TimeType

typ = Sec

)

Maximum processing time left for this process.

Units of time since system startup and begin of epoche.

Parameters:

typ

Indicator or the unit the time will be returned.

Returns:

Requested value in the indicated units.

Definition at line 99 of file Timing.cpp.

                                            {
  static longlong sys_start = 0;
  if ( 0 == sys_start )   {
    longlong c = currentTime(microSec);
    longlong t = tickCount();
    sys_start = 10*c - t;
  }
  return adjustTime(typ, sys_start);
}

std::string System::tempDirectory

(

)

Definition at line 86 of file Environment.cpp.

                                  {
   // Return a user configured or systemwide directory to create
   // temporary files in.
   const char *dir = ::getenv("TEMP");
   if (!dir)   dir = ::getenv("TEMPDIR");
   if (!dir)   dir = ::getenv("TEMP_DIR");
   if (!dir)   dir = ::getenv("TMP");
   if (!dir)   dir = ::getenv("TMPDIR");
   if (!dir)   dir = ::getenv("TMP_DIR");
   if (!dir) return homeDirectory();
   return dir;
}

ThreadHandle System::threadSelf

(

)

[inline]

thread handle "accessor"

Definition at line 93 of file System.h.

{ return (void*)0; }

longlong System::tickCount

(

)

Retrieve the number of ticks since system startup.

Returns:

Requested value in the indicated units.

Definition at line 67 of file Timing.cpp.

                              {
  longlong count = 10000;
#ifdef _WIN32
  count *= ::GetTickCount(); // Number of milliSec since system startup
#else
  struct tms buf;
  count *= 10*times(&buf);
#endif
  return count;
}

const std::string System::typeinfoName

(

const char *

class_name

)

Definition at line 364 of file System.cpp.

                                                            {
  std::string result;
#ifdef _WIN32
  long off = 0;
  if ( ::strncmp(class_name, "class ", 6) == 0 )   {
    // The returned name is prefixed with "class "
    off = 6;
  }
  if ( ::strncmp(class_name, "struct ", 7) == 0 )   {
    // The returned name is prefixed with "struct "
    off = 7;
  }
  if ( off > 0 )    {
    std::string tmp = class_name + off;
    long loc = 0;
    while( (loc = tmp.find("class ")) > 0 )  {
      tmp.erase(loc, 6);
    }
    loc = 0;
    while( (loc = tmp.find("struct ")) > 0 )  {
      tmp.erase(loc, 7);
    }
    result = tmp;
  }
  else  {
    result = class_name;
  }
  // Change any " *" to "*"
  while ( (off=result.find(" *")) != std::string::npos ) {
    result.replace(off, 2, "*");
  }
  // Change any " &" to "&"
  while ( (off=result.find(" &")) != std::string::npos ) {
    result.replace(off, 2, "&");
  }

#elif defined(__linux) || defined(__APPLE__)
    if ( ::strlen(class_name) == 1 ) {
      // See http://www.realitydiluted.com/mirrors/reality.sgi.com/dehnert_engr/cxx/abi.pdf
      // for details
      switch(class_name[0]) {
      case 'v':
        result = "void";
        break;
      case 'w':
        result = "wchar_t";
        break;
      case 'b':
        result = "bool";
        break;
      case 'c':
        result = "char";
        break;
      case 'a':
        result = "signed char";
        break;
      case 'h':
        result = "unsigned char";
        break;
      case 's':
        result = "short";
        break;
      case 't':
        result = "unsigned short";
        break;
      case 'i':
        result = "int";
        break;
      case 'j':
        result = "unsigned int";
        break;
      case 'l':
        result = "long";
        break;
      case 'm':
        result = "unsigned long";
        break;
      case 'x':
        result = "long long";
        break;
      case 'y':
        result = "unsigned long long";
        break;
      case 'n':
        result = "__int128";
        break;
      case 'o':
        result = "unsigned __int128";
        break;
      case 'f':
        result = "float";
        break;
      case 'd':
        result = "double";
        break;
      case 'e':
        result = "long double";
        break;
      case 'g':
        result = "__float128";
        break;
      case 'z':
        result = "ellipsis";
        break;
      }
    }
    else  {
      int   status;
      char* realname;
      realname = abi::__cxa_demangle(class_name, 0, 0, &status);
      if (realname == 0) return class_name;
      result = realname;
      free(realname);
      std::string::size_type pos = result.find(", ");
      while( std::string::npos != pos ) {
        result.replace( pos , 2 , "," ) ;
        pos = result.find(", ");
      }
    }
#endif
  return result;
}

const std::string System::typeinfoName

(

const std::type_info &

tinfo

)

Get platform independent information about the class type.

Definition at line 361 of file System.cpp.

                                                               {
  return typeinfoName(tinfo.name());
}

unsigned long System::unloadDynamicLib

(

ImageHandle

handle

)

unload dynamic link library

Definition at line 156 of file System.cpp.

                                                            {
#ifdef _WIN32
  if ( !::FreeLibrary((HINSTANCE)handle) ) {
#elif defined(linux) || defined(__APPLE__)
  ::dlclose( handle );
  if ( 0 ) {
#elif __hpux
  // On HP we have to run finalization ourselves.....
  Creator pFinalize = 0;
  if ( getProcedureByName(handle, "_fini", &pFinalize) ) {
    pFinalize();
  }
  HMODULE* mod = (HMODULE*)handle;
  if ( 0 == ::shl_unload( mod->dsc.handle ) ) {
    delete mod;
  }
  else {
#else
  if (false){
#endif
    return getLastError();
  }
  return 1;
}

longlong System::upTime

(

TimeType

typ = Hour

)

Maximum processing time left for this process.

Units of time since system startup in requested units.

Parameters:

typ

Indicator or the unit the time will be returned.

Returns:

Requested value in the indicated units.

Definition at line 110 of file Timing.cpp.

                                       {
  static longlong sys_start = 10*systemStart(microSec);
  return adjustTime(typ, 10*currentTime(microSec)-sys_start);
}

longlong System::userTime	(	TimeType	typ = milliSec,
		InfoType	fetch = Times,
		long	pid = -1
	)

CPU user mode time of process in milli seconds.

CPU kernel time of process in milli seconds.

Parameters:

	typ	Indicator or the unit the time will be returned.
	fetch	Indicator of the information to be fetched. If Fetch_None, the information will not be updated.
	pid	Process ID of which the information will be returned

Returns:

Requested value in the indicated units.

Definition at line 160 of file Timing.cpp.

                                                                {
  longlong usertime = 0;
  KERNEL_USER_TIMES info;
  if ( fetch != NoFetch && getProcess()->query(pid, fetch, &info) )   {
    usertime = adjustTime(typ, info.UserTime );
  }
  return usertime;
}

long System::virtualMemory	(	MemoryUnit	unit = kByte,
		InfoType	fetch = Memory,
		long	pid = -1
	)

Basic Process Information: priority boost.

Definition at line 213 of file Memory.cpp.

                                                                      {
  VM_COUNTERS info;
  if ( fetch != NoFetch && getProcess()->query(pid, fetch, &info) )
    return adjustMemory(unit, info.VirtualSize);
  return -2;
}

long System::virtualMemoryLimit	(	MemoryUnit	unit = kByte,
		InfoType	fetch = Quota,
		long	pid = -1
	)

System Process Limits: Maximum amount of the page file this process is allowed to use.

Definition at line 229 of file Memory.cpp.

                                                                           {
  QUOTA_LIMITS quota;
  if ( fetch != NoFetch && getProcess()->query(pid, fetch, &quota) )    {
    if ( long(quota.PagefileLimit) == -1 )
      return -1;//LONG_MAX;
    return adjustMemory(unit, quota.PagefileLimit);
  }
  return 0;
}

long System::virtualMemoryPeak	(	MemoryUnit	unit = kByte,
		InfoType	fetch = Memory,
		long	pid = -1
	)

Basic Process Information: priority boost.

Definition at line 221 of file Memory.cpp.

                                                                          {
  VM_COUNTERS info;
  if ( fetch != NoFetch && getProcess()->query(pid, fetch, &info) )
    return adjustMemory(unit, info.PeakVirtualSize);
  return -2;
}