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

Namespaces
	Linux
	Namespace holding Linux specific functions.

	MacOS
	Namespace holding MacOS specific functions.

	Win32
	Namespace holding Windows specific functions.

Classes
struct	IO_COUNTERS
	Process I/O Counters NtQueryInformationProcess using ProcessIoCounters. More...

struct	KERNEL_USER_TIMES
	Process/Thread System and User Time NtQueryInformationProcess using ProcessTimes NtQueryInformationThread using ThreadTimes. More...

class	PathResolver

struct	POOLED_USAGE_AND_LIMITS
	Process Pooled Quota Usage and Limits NtQueryInformationProcess using ProcessPooledUsageAndLimits. More...

struct	PROCESS_BASIC_INFORMATION

class	ProcessDescriptor

class	ProcessTime
	Simple class to hold the time information of a process. More...

struct	QUOTA_LIMITS
	Process Quotas NtQueryInformationProcess using ProcessQuotaLimits NtQueryInformationProcess using ProcessPooledQuotaLimits NtSetInformationProcess using ProcessQuotaLimits. More...

struct	VM_COUNTERS
	Process Virtual Memory Counters NtQueryInformationProcess using ProcessVmCounters. More...

Typedefs
typedef void *	ImageHandle
	Definition of an image handle. More...

typedef void *	ProcessHandle
	Definition of the process handle. More...

typedef unsigned long(*	EntryPoint) (const unsigned long iid, void **ppvObject)
	Definition of the "generic" DLL entry point function. More...

typedef void (	Creator) ()
	Definition of the "generic" DLL entry point function. More...

typedef void *	ThreadHandle
	A Thread handle. More...

typedef struct _PEB *	PPEB
	Basic Process Information NtQueryInformationProcess using ProcessBasicInfo. More...

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, Native }
	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. More...

GAUDI_API long	breakExecution (long pid)
	Break the execution of the application and invoke the debugger in a remote process. More...

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) More...

GAUDI_API long	procID ()
	Basic Process Information: Process ID. More...

GAUDI_API long	parentID (InfoType fetch=ProcessBasics, long pid=-1)
	Basic Process Information: Parent's process ID. More...

GAUDI_API long	affinityMask (InfoType fetch=ProcessBasics, long pid=-1)
	Basic Process Information: Affinity mask. More...

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!) More...

GAUDI_API long	basePriority (InfoType fetch=ProcessBasics, long pid=-1)
	Basic Process Information: Base priority. More...

GAUDI_API long	priorityBoost (InfoType fetch=PriorityBoost, long pid=-1)
	Basic Process Information: priority boost. More...

GAUDI_API long	numPageFault (InfoType fetch=Memory, long pid=-1)
	Basic Process Information: Number of page faults. More...

GAUDI_API long	pagefileUsage (MemoryUnit unit=kByte, InfoType fetch=Memory, long pid=-1)
	Basic Process Information: Current page file usage. More...

GAUDI_API long	pagefileUsagePeak (MemoryUnit unit=kByte, InfoType fetch=Memory, long pid=-1)
	Basic Process Information: Peak usage of page file. More...

GAUDI_API long	pagefileUsageLimit (MemoryUnit unit=kByte, InfoType fetch=Quota, long pid=-1)
	Basic Process Information: Peak usage of page file. More...

GAUDI_API long	nonPagedMemory (MemoryUnit unit=kByte, InfoType fetch=Memory, long pid=-1)
	Basic Process Information: Current usage of non paged memory. More...

GAUDI_API long	nonPagedMemoryPeak (MemoryUnit unit=kByte, InfoType fetch=Memory, long pid=-1)
	Basic Process Information: Peak usage of non paged memory. More...

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. More...

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'. More...

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'. More...

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'. More...

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. More...

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. More...

GAUDI_API long	mappedMemory (MemoryUnit unit=kByte, InfoType fetch=Memory, long pid=-1)
	Basic Process Information: priority boost. More...

GAUDI_API long	mappedMemoryPeak (MemoryUnit unit=kByte, InfoType fetch=Memory, long pid=-1)
	Basic Process Information: priority boost. More...

GAUDI_API long	virtualMemory (MemoryUnit unit=kByte, InfoType fetch=Memory, long pid=-1)
	Basic Process Information: priority boost. More...

GAUDI_API long	virtualMemoryPeak (MemoryUnit unit=kByte, InfoType fetch=Memory, long pid=-1)
	Basic Process Information: priority boost. More...

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. More...

GAUDI_API const std::string &	moduleName ()
	Get the name of the (executable/DLL) file without file-type. More...

GAUDI_API const std::string &	moduleNameFull ()
	Get the full name of the (executable/DLL) file. More...

GAUDI_API ModuleType	moduleType ()
	Get type of the module. More...

GAUDI_API ProcessHandle	processHandle ()
	Handle to running process. More...

GAUDI_API ImageHandle	moduleHandle ()
	Handle to currently executed module. More...

GAUDI_API ImageHandle	exeHandle ()
	Handle to the executable file running. More...

GAUDI_API const std::string &	exeName ()
	Name of the executable file running. More...

GAUDI_API const std::vector< std::string >	linkedModules ()
	Vector of names of linked modules. More...

GAUDI_API void	setModuleHandle (ImageHandle handle)
	Attach module handle. More...

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. More...

GAUDI_API unsigned long	unloadDynamicLib (ImageHandle handle)
	unload dynamic link library More...

GAUDI_API unsigned long	getProcedureByName (ImageHandle handle, const std::string &name, EntryPoint *pFunction)
	Get a specific function defined in the DLL. More...

GAUDI_API unsigned long	getProcedureByName (ImageHandle handle, const std::string &name, Creator *pFunction)
	Get a specific function defined in the DLL. More...

GAUDI_API unsigned long	getLastError ()
	Get last system known error. More...

GAUDI_API const std::string	getLastErrorString ()
	Get last system error as string. More...

GAUDI_API const std::string	getErrorString (unsigned long error)
	Retrieve error code as string for a given error. More...

GAUDI_API const std::string	typeinfoName (const std::type_info &)
	Get platform independent information about the class type. More...

GAUDI_API const std::string	typeinfoName (const char *)

GAUDI_API const std::string &	hostName ()
	Host name. More...

GAUDI_API const std::string &	osName ()
	OS name. More...

GAUDI_API const std::string &	osVersion ()
	OS version. More...

GAUDI_API const std::string &	machineType ()
	Machine type. More...

GAUDI_API int	instructionsetLevel ()
	Instruction Set "Level". More...

GAUDI_API const std::string &	accountName ()
	User login name. More...

GAUDI_API long	numCmdLineArgs ()
	Number of arguments passed to the commandline. More...

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

GAUDI_API const std::vector< std::string >	cmdLineArgs ()
	Command line arguments including executable name as arg[0] as vector of strings. More...

GAUDI_API char **	argv ()
	char** command line arguments including executable name as arg[0]; You may not modify them! More...

GAUDI_API std::string	getEnv (const char *var)
	get a particular environment variable (returning "UNKNOWN" if not set) More...

GAUDI_API bool	getEnv (const char *var, std::string &value)
	get a particular environment variable, storing the value in the passed string if the variable is set. More...

bool	getEnv (const std::string &var, std::string &value)

GAUDI_API std::vector< std::string >	getEnv ()
	get all environment variables More...

GAUDI_API int	setEnv (const std::string &name, const std::string &value, int overwrite=1)
	Set an environment variables. More...

GAUDI_API bool	isEnvSet (const char *var)
	Check if an environment variable is set or not. More...

ThreadHandle	threadSelf ()
	thread handle "accessor" More...

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 long long	adjustTime (TimeType typ, long long timevalue)
	Convert time from OS native time to requested representation (Experts only) More...

template<TimeType T>
long long	adjustTime (long long timevalue)
	Convert the time from OS native time to requested representation (Experts only) More...

GAUDI_API long long	ellapsedTime (TimeType typ=milliSec, InfoType fetch=Times, long pid=-1)
	Elapsed time since start of process in milliseconds. More...

GAUDI_API long long	kernelTime (TimeType typ=milliSec, InfoType fetch=Times, long pid=-1)
	CPU kernel mode time of process in milliseconds. More...

GAUDI_API long long	userTime (TimeType typ=milliSec, InfoType fetch=Times, long pid=-1)
	CPU user mode time of process in milliseconds. More...

GAUDI_API long long	cpuTime (TimeType typ=milliSec, InfoType fetch=Times, long pid=-1)
	Consumed CPU time of process in milliseconds. More...

GAUDI_API long long	remainingTime (TimeType typ=milliSec, InfoType fetch=Quota, long pid=-1)
	Maximum processing time left for this process. More...

GAUDI_API long long	creationTime (TimeType typ=milliSec, InfoType fetch=Times, long pid=-1)
	Process Creation time. More...

GAUDI_API long long	systemStart (TimeType typ=Sec)
	Maximum processing time left for this process. More...

GAUDI_API long long	upTime (TimeType typ=Hour)
	Maximum processing time left for this process. More...

template<TimeType T>
GAUDI_API long long	currentTime ()
	Retrieve absolute system time. More...

GAUDI_API long long	currentTime (TimeType typ=milliSec)
	Get current time in specificed units. More...

GAUDI_API long long	tickCount ()
	Retrieve the number of ticks since system startup. More...

GAUDI_API ProcessTime	getProcessTime (long pid=-1)
	Retrieve the process time data for a process. More...

template<>
long long	adjustTime< Year > (long long t)

template<>
long long	adjustTime< Day > (long long t)

template<>
long long	adjustTime< Hour > (long long t)

template<>
long long	adjustTime< Min > (long long t)

template<>
long long	adjustTime< Sec > (long long t)

template<>
long long	adjustTime< milliSec > (long long t)

template<>
long long	adjustTime< microSec > (long long t)

template<>
long long	adjustTime< nanoSec > (long long t)

template<>
long long	adjustTime< Month > (long long t)

template<>
long long	adjustTime< Native > (long long t)

template<TimeType T>
long long	currentTime ()
	Retrieve absolute system time. More...

template long long	currentTime< Year > ()

template long long	currentTime< Month > ()

template long long	currentTime< Day > ()

template long long	currentTime< Hour > ()

template long long	currentTime< Min > ()

template long long	currentTime< Sec > ()

template long long	currentTime< milliSec > ()

template long long	currentTime< microSec > ()

template long long	currentTime< nanoSec > ()

template long long	currentTime< Native > ()

ProcessDescriptor *	getProcess ()
	Retrieve Process structure. More...

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 elapsed 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

◆ Creator

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

Definition of the "generic" DLL entry point function.

Definition at line 43 of file System.h.

◆ EntryPoint

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

Definition of the "generic" DLL entry point function.

Definition at line 41 of file System.h.

◆ ImageHandle

typedef void * System::ImageHandle

Definition of an image handle.

Definition at line 25 of file ModuleInfo.h.

◆ PPEB

typedef struct _PEB* System::PPEB

Basic Process Information NtQueryInformationProcess using ProcessBasicInfo.

Definition at line 26 of file ProcessDescriptor.h.

◆ ProcessHandle

typedef void * System::ProcessHandle

Definition of the process handle.

Definition at line 27 of file ModuleInfo.h.

◆ ThreadHandle

typedef void* System::ThreadHandle

A Thread handle.

Definition at line 114 of file System.h.

Enumeration Type Documentation

◆ InfoType

enum System::InfoType

Enumeration for fetching information.

Enumerator
NoFetch
RemainTime
Times
ProcessBasics
PriorityBoost
Memory
Quota
System
Modules
IO

Definition at line 15 of file SystemBase.h.

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

◆ MemoryUnit

enum System::MemoryUnit

Unit of memory.

Enumerator
Byte
kByte
MByte
GByte
TByte
PByte
EByte

Definition at line 50 of file Memory.h.

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

◆ ModuleType

enum System::ModuleType

Enumerator
UNKNOWN
SHAREDLIB
EXECUTABLE

Definition at line 23 of file ModuleInfo.h.

23 { UNKNOWN, SHAREDLIB, EXECUTABLE };

◆ PR_file_type

enum System::PR_file_type

Enumerator
PR_regular_file
PR_directory

Definition at line 31 of file PathResolver.cpp.

31 { PR_regular_file, PR_directory } PR_file_type;

◆ PR_search_type

enum System::PR_search_type

Enumerator
PR_local
PR_recursive

Definition at line 33 of file PathResolver.cpp.

33 { PR_local, PR_recursive } PR_search_type;

◆ ProcessInfoCommand

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 16 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
   };

◆ TimeType

enum System::TimeType

Time type for conversion.

Enumerator
Year
Month
Day
Hour
Min
Sec
milliSec
microSec
nanoSec
Native

Definition at line 54 of file Timing.h.

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

Function Documentation

◆ accountName()

const std::string & System::accountName ( )

User login name.

Definition at line 339 of file System.cpp.

                                      {
   static const std::string account = Platform::accountName();
   return account;
 }

◆ adjustMemory()

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 25 of file Memory.cpp.

                                                        {
   if ( value != -1 ) {
     switch ( unit ) {
     case Byte:
       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;
 }

◆ adjustTime() [1/2]

template<TimeType T>

long long System::adjustTime ( long long timevalue )

inline

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

◆ adjustTime() [2/2]

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

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

unfortunately "-ansi" flag turn off the 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 47 of file Timing.cpp.

                                                         {
   if ( t != -1 ) {
 #ifndef _WIN32
 //  t /= CLK_TCK ;     // needs division by clock tick unit
  
 #endif
     switch ( typ ) {
     case Year:
       return adjustTime<Year>( t );
     case Month:
       return adjustTime<Month>( t );
     case Day:
       return adjustTime<Day>( t );
     case Hour:
       return adjustTime<Hour>( t );
     case Min:
       return adjustTime<Min>( t );
     case Sec:
       return adjustTime<Sec>( t );
     case milliSec:
       return adjustTime<milliSec>( t );
     case microSec:
       return adjustTime<microSec>( t );
     case nanoSec:
       return adjustTime<nanoSec>( t );
     case Native:
       return adjustTime<Native>( t );
     default:
       return t;
     }
   }
   return t;
 }

◆ adjustTime< Day >()

template<>

long long System::adjustTime< Day > ( long long t )

inline

Definition at line 209 of file Timing.h.

                                                   {
     return ( t == -1 ) ? t : t /= ( 1LL * 24 * 60 * 60 * 1000 * 1000 * 10 );
   }

◆ adjustTime< Hour >()

template<>

long long System::adjustTime< Hour > ( long long t )

inline

Definition at line 213 of file Timing.h.

                                                    {
     return ( t == -1 ) ? t : t /= ( 1LL * 60 * 60 * 1000 * 1000 * 10 );
   }

◆ adjustTime< microSec >()

template<>

long long System::adjustTime< microSec > ( long long t )

inline

Definition at line 229 of file Timing.h.

                                                        {
     return ( t == -1 ) ? t : t /= ( 10LL );
   }

◆ adjustTime< milliSec >()

template<>

long long System::adjustTime< milliSec > ( long long t )

inline

Definition at line 225 of file Timing.h.

                                                        {
     return ( t == -1 ) ? t : t /= ( 1000 * 10 );
   }

◆ adjustTime< Min >()

template<>

long long System::adjustTime< Min > ( long long t )

inline

Definition at line 217 of file Timing.h.

                                                   {
     return ( t == -1 ) ? t : t /= ( 60 * 1000 * 1000 * 10 );
   }

◆ adjustTime< Month >()

template<>

long long System::adjustTime< Month > ( long long t )

inline

Definition at line 237 of file Timing.h.

                                                     {
     return ( t == -1 ) ? t : t /= ( 1LL * 30 * 24 * 60 * 60 * 1000 * 1000 * 10 );
   }

◆ adjustTime< nanoSec >()

template<>

long long System::adjustTime< nanoSec > ( long long t )

inline

Definition at line 233 of file Timing.h.

                                                       {
     return ( t == -1 ) ? t : t *= 100LL;
   }

◆ adjustTime< Native >()

template<>

long long System::adjustTime< Native > ( long long t )

inline

Definition at line 241 of file Timing.h.

                                                      {
     return t;
   }

◆ adjustTime< Sec >()

template<>

long long System::adjustTime< Sec > ( long long t )

inline

Definition at line 221 of file Timing.h.

                                                   {
     return ( t == -1 ) ? t : t /= ( 1000 * 1000 * 10 );
   }

◆ adjustTime< Year >()

template<>

long long System::adjustTime< Year > ( long long t )

inline

Definition at line 205 of file Timing.h.

                                                    {
     return ( t == -1 ) ? t : t /= ( 1LL * 365 * 24 * 60 * 60 * 1000 * 1000 * 10 );
   }

◆ affinityMask()

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

Basic Process Information: Affinity mask.

Definition at line 77 of file Memory.cpp.

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

◆ argc()

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 348 of file System.cpp.

348 { return cmdLineArgs().size(); }

◆ argv()

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].

Definition at line 357 of file System.cpp.

                     {
   auto helperFunc = []( const std::vector<std::string>& args ) -> std::vector<const char*> {
     std::vector<const char*> result;
     std::transform( args.begin(), args.end(), std::back_inserter( result ),
                     []( const std::string& s ) { return s.c_str(); } );
     return result;
   };
   static const std::vector<const char*> args = helperFunc( cmdLineArgs() );
   // We rely here on the fact that a vector's allocation table is contiguous
   return (char**)&( args[0] );
 }

◆ backTrace() [1/2]

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

Definition at line 433 of file System.cpp.

                                                                              {
   try {
     // Always hide the first two levels of the stack trace (that's us)
     const size_t totalOffset = offset + 2;
     const size_t totalDepth  = depth + totalOffset;
  
     std::string fnc, lib;
  
     std::vector<void*> addresses( totalDepth, nullptr );
     const size_t       count = System::backTrace( addresses.data(), totalDepth );
     for ( size_t i = totalOffset; i < count; ++i ) {
       void* addr = nullptr;
  
       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();
       }
     }
     return true;
   } catch ( const std::bad_alloc& e ) { return false; }
 }

◆ backTrace() [2/2]

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

◆ basePriority()

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

Basic Process Information: Base priority.

Definition at line 57 of file Memory.cpp.

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

◆ breakExecution() [1/2]

long System::breakExecution ( )

Break the execution of the application and invoke the debugger.

Definition at line 43 of file Debugger.cpp.

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

◆ breakExecution() [2/2]

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 53 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 clue how to do this in linux
   return pid;
 #endif
 }

◆ cmdLineArgs()

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 351 of file System.cpp.

                                                {
   static const std::vector<std::string> args = Platform::cmdLineArgs();
   return args;
 }

◆ cpuTime()

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

Consumed CPU time of process in milliseconds.

CPU kernel time of process in milliseconds.

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 197 of file Timing.cpp.

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

◆ creationTime()

long long 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 145 of file Timing.cpp.

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

◆ currentTime() [1/3]

template<TimeType T>

GAUDI_API long long System::currentTime ( )

inline

Retrieve absolute system time.

Parameters

typ	Indicator or the unit the time will be returned.

Returns: Requested value in the indicated units. Get current time in specificed units via template parameter (inlined)

Definition at line 247 of file Timing.h.

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

◆ currentTime() [2/3]

template<TimeType T>

long long System::currentTime ( )

inline

Retrieve absolute system time.

Parameters

typ	Indicator or the unit the time will be returned.

Returns: Requested value in the indicated units. Get current time in specificed units via template parameter (inlined)

Definition at line 247 of file Timing.h.

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

◆ currentTime() [3/3]

long long System::currentTime ( TimeType typ = milliSec )

Get current time in specificed units.

Retrieve current system time.

Definition at line 101 of file Timing.cpp.

                                             {
   switch ( typ ) {
   case Year:
     return currentTime<Year>();
   case Month:
     return currentTime<Month>();
   case Day:
     return currentTime<Day>();
   case Hour:
     return currentTime<Hour>();
   case Min:
     return currentTime<Min>();
   case Sec:
     return currentTime<Sec>();
   case milliSec:
     return currentTime<milliSec>();
   case microSec:
     return currentTime<microSec>();
   case nanoSec:
     return currentTime<nanoSec>();
   case Native:
     return currentTime<Native>();
   }
   return currentTime<Native>();
 }

◆ currentTime< Day >()

template long long System::currentTime< Day > ( )

◆ currentTime< Hour >()

template long long System::currentTime< Hour > ( )

◆ currentTime< microSec >()

template long long System::currentTime< microSec > ( )

◆ currentTime< milliSec >()

template long long System::currentTime< milliSec > ( )

◆ currentTime< Min >()

template long long System::currentTime< Min > ( )

◆ currentTime< Month >()

template long long System::currentTime< Month > ( )

◆ currentTime< nanoSec >()

template long long System::currentTime< nanoSec > ( )

◆ currentTime< Native >()

template long long System::currentTime< Native > ( )

◆ currentTime< Sec >()

template long long System::currentTime< Sec > ( )

◆ currentTime< Year >()

template long long System::currentTime< Year > ( )

◆ ellapsedTime()

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

Elapsed time since start of process in milliseconds.

Ellapsed time since start of process in milliseconds.

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 169 of file Timing.cpp.

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

◆ exeHandle()

System::ImageHandle System::exeHandle ( )

Handle to the executable file running.

Definition at line 149 of file ModuleInfo.cpp.

                                     {
 #ifdef _WIN32
   if ( processHandle() ) {
     static HINSTANCE handle = 0;
     DWORD            cbNeeded;
     if ( 0 == handle && _psApi ) {
       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 ( !info ) {
     void* handle = ::dlopen( nullptr, RTLD_LAZY );
     // printf("Exe handle:%X\n", handle);
     if ( handle ) {
       void* func = ::dlsym( handle, "main" );
       // printf("Exe:Func handle:%X\n", func);
       if ( 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
   return 0;
 }

◆ exeName()

const std::string & System::exeName ( )

Name of the executable file running.

Definition at line 185 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 && processHandle() ) {
       _psApi.GetModuleFileNameExA( processHandle(), (HINSTANCE)exeHandle(), name, sizeof( name ) );
       module = name;
     }
 #elif defined( __linux ) || defined( __APPLE__ )
     char cmd[512];
     ::sprintf( cmd, "/proc/%d/exe", ::getpid() );
     module = "Unknown";
     if ( ::readlink( cmd, name, sizeof( name ) ) >= 0 ) module = name;
 #elif __hpux
     if ( ::realpath( ( (HMODULE*)exeHandle() )->dsc.filename, name ) ) module = name;
 #endif
   }
   return module;
 }

◆ exitStatus()

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 84 of file Memory.cpp.

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

◆ getEnv() [1/4]

std::vector< std::string > System::getEnv ( )

get all environment variables

get all defined environment vars

Definition at line 403 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] != nullptr; ++i ) { vars.push_back( environ[i] ); }
   return vars;
 }

◆ getEnv() [2/4]

std::string System::getEnv ( const char * var )

get a particular environment variable (returning "UNKNOWN" if not set)

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

Definition at line 376 of file System.cpp.

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

◆ getEnv() [3/4]

bool System::getEnv	(	const char *	var,
		std::string &	value
	)

get a particular environment variable, storing the value in the passed string if the variable is set.

get a particular env var, storing the value in the passed string (if set)

Returns true if the variable is set, false otherwise.

Definition at line 386 of file System.cpp.

                                                        {
   char* env;
   if ( ( env = getenv( var ) ) != nullptr ) {
     value = env;
     return true;
   } else {
     return false;
   }
 }

◆ getEnv() [4/4]

bool System::getEnv	(	const std::string &	var,
		std::string &	value
	)

inline

Definition at line 96 of file System.h.

96 { return getEnv( var.c_str(), value ); }

◆ getErrorString()

const std::string System::getErrorString ( unsigned long error )

Retrieve error code as string for a given error.

Definition at line 271 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( nullptr );
   // Remember: for linux dl* routines must be handled differently!
   if ( error == 0xAFFEDEAD ) {
     cerrString = ::dlerror();
     if ( !cerrString ) cerrString = ::strerror( error );
     if ( !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;
 }

◆ getLastError()

unsigned long System::getLastError ( )

Get last system known error.

Retrieve last error code.

Definition at line 255 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
 }

◆ getLastErrorString()

const std::string System::getLastErrorString ( )

Get last system error as string.

Retrieve last error code as string.

Definition at line 265 of file System.cpp.

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

◆ getProcedureByName() [1/2]

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

Get a specific function defined in the DLL.

Definition at line 250 of file System.cpp.

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

◆ getProcedureByName() [2/2]

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

Get a specific function defined in the DLL.

Definition at line 204 of file System.cpp.

                                                                                                            {
 #ifdef _WIN32
   *pFunction = ( EntryPoint )::GetProcAddress( (HINSTANCE)handle, name.data() );
   if ( 0 == *pFunction ) { return System::getLastError(); }
   return 1;
 #elif defined( __linux )
   *pFunction = reinterpret_cast<EntryPoint>( ::dlsym( handle, name.c_str() ) );
   if ( !*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;
 #else
   return 0;
 #endif
 }

◆ getProcess()

ProcessDescriptor * System::getProcess ( )

inline

Retrieve Process structure.

Definition at line 141 of file ProcessDescriptor.h.

                                          {
     static ProcessDescriptor p;
     return &p;
   }

◆ getProcessTime()

ProcessTime System::getProcessTime ( long pid = -1 )

Retrieve the process time data for a process.

Get the process time data for a process (by default the current) as a ProcessTime object.

Definition at line 207 of file Timing.cpp.

                                          {
     KERNEL_USER_TIMES info;
     if ( getProcess()->query( pid, Times, &info ) ) {
       return ProcessTime( info.KernelTime, info.UserTime, currentTime<Native>() - info.CreateTime );
     }
     return ProcessTime(); // return 0s in case of problems
   }

◆ getStackLevel()

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

◆ homeDirectory()

std::string System::homeDirectory ( )

Definition at line 64 of file Environment.cpp.

                                 {
   // Return the user's home directory.
   std::string home_dir = "./";
   // Try to replace the current value with the content of several
   // environment variables
   if ( !( System::getEnv( "home", home_dir ) || System::getEnv( "HOME", home_dir ) ) ) {
     // for Windows NT HOME might be defined as either $(HOMESHARE)/$(HOMEPATH)
     //                                         or     $(HOMEDRIVE)/$(HOMEPATH)
     if ( System::getEnv( "HOMESHARE", home_dir ) || System::getEnv( "HOMEDRIVE", home_dir ) ) {
       std::string path;
       if ( System::getEnv( "HOMEPATH", path ) ) home_dir += path;
     }
   }
   return home_dir;
 }

◆ hostName()

const std::string & System::hostName ( )

Host name.

Definition at line 306 of file System.cpp.

                                   {
   static const std::string host = Platform::hostName();
   return host;
 }

◆ instructionsetLevel()

int System::instructionsetLevel ( )

Instruction Set "Level".

Definition at line 329 of file System.cpp.

                                 {
 #ifdef __x86_64
   using namespace Gaudi;
   return instrset_detect();
 #else
   return -1;
 #endif
 }

◆ isEnvSet()

bool System::isEnvSet ( const char * var )

Check if an environment variable is set or not.

Definition at line 396 of file System.cpp.

396 { return getenv( var ) != nullptr; }

◆ kernelTime()

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

CPU kernel mode time of process in milliseconds.

CPU kernel time of process in milliseconds.

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 179 of file Timing.cpp.

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

◆ linkedModules()

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

Vector of names of linked modules.

Definition at line 207 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 ) {
       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;
 }

◆ loadDynamicLib()

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

Load dynamic link library.

Definition at line 136 of file System.cpp.

                                                                                  {
   unsigned long res = 0;
   // 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 imgName;
     if ( getEnv( name, imgName ) ) {
       res = loadWithoutEnvironment( imgName, handle );
     } else {
       // build the dll name
       std::string dllName = name;
 // Add a possible "lib" prefix to the name on unix platforms. But only if
 // it's not an absolute path name.
 #if defined( __linux ) || defined( __APPLE__ )
       if ( ( dllName.find( '/' ) == std::string::npos ) && ( dllName.compare( 0, 3, "lib" ) != 0 ) ) {
         dllName = "lib" + dllName;
       }
 #endif // unix
       // Now try loading the library with all possible suffixes supported by the
       // platform.
       for ( const char* suffix : SHLIB_SUFFIXES ) {
         // Add the suffix if necessary.
         std::string  libName = dllName;
         const size_t len     = strlen( suffix );
         if ( dllName.compare( dllName.length() - len, len, suffix ) != 0 ) { libName += suffix; }
         // Try to load the library.
         res = loadWithoutEnvironment( libName, handle );
         // If the load succeeded, stop here.
         if ( res == 1 ) { break; }
       }
     }
     if ( res != 1 ) {
 #if defined( __linux ) || defined( __APPLE__ )
       errno = 0xAFFEDEAD;
 #endif
       // std::cout << "System::loadDynamicLib>" << getLastErrorString() << std::endl;
     }
   }
   return res;
 }

◆ machineType()

const std::string & System::machineType ( )

Machine type.

Definition at line 324 of file System.cpp.

                                      {
   static const std::string mach = Platform::machineType();
   return mach;
 }

◆ mappedMemory()

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

Basic Process Information: priority boost.

Definition at line 178 of file Memory.cpp.

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

◆ mappedMemoryPeak()

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

Basic Process Information: priority boost.

Definition at line 185 of file Memory.cpp.

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

◆ maxMemoryLimit()

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 201 of file Memory.cpp.

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

◆ minMemoryLimit()

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 193 of file Memory.cpp.

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

◆ moduleHandle()

System::ImageHandle System::moduleHandle ( )

Handle to currently executed module.

Definition at line 128 of file ModuleInfo.cpp.

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

◆ moduleName()

const std::string & System::moduleName ( )

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

Retrieve base name of module.

Definition at line 45 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 ) {
         _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;
 }

◆ moduleNameFull()

const std::string & System::moduleNameFull ( )

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

Retrieve full name of module.

Definition at line 68 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 ) {
         _psApi.GetModuleFileNameExA( processHandle(), (HINSTANCE)moduleHandle(), name, sizeof( name ) );
         module = name;
       }
 #else
  
 #  if defined( __linux ) || defined( __APPLE__ )
       const char* path = ( (Dl_info*)moduleHandle() )->dli_fname;
 #  elif __hpux
       const char* path = ( (HMODULE*)moduleHandle() )->dsc.filename;
 #  endif
       if ( ::realpath( path, name ) ) module = name;
 #endif
     }
   }
   return module;
 }

◆ moduleType()

System::ModuleType System::moduleType ( )

Get type of the module.

Definition at line 94 of file ModuleInfo.cpp.

                                     {
   static ModuleType type = UNKNOWN;
   if ( type == UNKNOWN ) {
     const std::string& module = moduleNameFull();
     size_t             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;
 }

◆ nonPagedMemory()

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;
 }

◆ nonPagedMemoryLimit()

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;
 }

◆ nonPagedMemoryPeak()

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;
 }

◆ numCmdLineArgs()

long System::numCmdLineArgs ( )

Number of arguments passed to the commandline.

Definition at line 345 of file System.cpp.

345 { return cmdLineArgs().size(); }

◆ numPageFault()

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;
 }

◆ osName()

const std::string & System::osName ( )

OS name.

Definition at line 312 of file System.cpp.

                                 {
   static const std::string osname = Platform::osName();
   return osname;
 }

◆ osVersion()

const std::string & System::osVersion ( )

OS version.

Definition at line 318 of file System.cpp.

                                    {
   static const std::string osver = Platform::osVersion();
   return osver;
 }

◆ pagedMemory()

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;
 }

◆ pagedMemoryLimit()

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;
 }

◆ pagedMemoryPeak()

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;
 }

◆ pagefileUsage()

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 153 of file Memory.cpp.

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

◆ pagefileUsageLimit()

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 168 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;
 }

◆ pagefileUsagePeak()

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 160 of file Memory.cpp.

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

◆ parentID()

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

Basic Process Information: Parent's process ID.

Definition at line 70 of file Memory.cpp.

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

◆ PathResolverFindDataFile()

std::string System::PathResolverFindDataFile ( const std::string & logical_file_name )

Definition at line 169 of file PathResolver.cpp.

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

◆ PathResolverFindXMLFile()

std::string System::PathResolverFindXMLFile ( const std::string & logical_file_name )

Definition at line 165 of file PathResolver.cpp.

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

◆ priorityBoost()

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

Basic Process Information: priority boost.

Definition at line 91 of file Memory.cpp.

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

◆ processHandle()

void * System::processHandle ( )

Handle to running process.

Retrieve processhandle.

Definition at line 116 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;
 }

◆ procID()

long System::procID ( )

Basic Process Information: Process ID.

Definition at line 64 of file Memory.cpp.

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

◆ remainingTime()

long long 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 155 of file Timing.cpp.

                                                                         {
   long long    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;
 }

◆ resolveEnv()

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

Definition at line 57 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;
 }

◆ setEnv()

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 489 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
 }

◆ setModuleHandle()

void System::setModuleHandle ( System::ImageHandle handle )

Attach module handle.

Definition at line 126 of file ModuleInfo.cpp.

126 { ModuleHandle = handle; }

◆ systemStart()

long long 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 128 of file Timing.cpp.

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

◆ tempDirectory()

std::string System::tempDirectory ( )

Definition at line 80 of file Environment.cpp.

                                 {
   // Return a user configured or systemwide directory to create
   // temporary files in.
   std::string dir;
   if ( System::getEnv( "TEMP", dir ) || System::getEnv( "TEMPDIR", dir ) || System::getEnv( "TEMP_DIR", dir ) ||
        System::getEnv( "TMP", dir ) || System::getEnv( "TMPDIR", dir ) || System::getEnv( "TMP_DIR", dir ) )
     return dir;
   else
     return homeDirectory();
 }

◆ threadSelf()

ThreadHandle System::threadSelf ( )

inline

thread handle "accessor"

Definition at line 116 of file System.h.

116 { return (void*)0; }

◆ tickCount()

long long System::tickCount ( )

Retrieve the number of ticks since system startup.

Returns: Requested value in the indicated units.

Definition at line 87 of file Timing.cpp.

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

◆ typeinfoName() [1/2]

const std::string System::typeinfoName ( const char * class_name )

Definition at line 303 of file System.cpp.

303 { return Platform::typeinfoName( class_name ); }

◆ typeinfoName() [2/2]

const std::string System::typeinfoName ( const std::type_info & tinfo )

Get platform independent information about the class type.

Definition at line 301 of file System.cpp.

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

◆ unloadDynamicLib()

unsigned long System::unloadDynamicLib ( ImageHandle handle )

unload dynamic link library

Definition at line 181 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;
 }

◆ upTime()

long long 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 139 of file Timing.cpp.

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

◆ userTime()

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

CPU user mode time of process in milliseconds.

CPU kernel time of process in milliseconds.

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 189 of file Timing.cpp.

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

◆ virtualMemory()

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

Basic Process Information: priority boost.

Definition at line 209 of file Memory.cpp.

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

◆ virtualMemoryLimit()

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 223 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;
 }

◆ virtualMemoryPeak()

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

Basic Process Information: priority boost.

Definition at line 216 of file Memory.cpp.

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

Namespaces

Classes

Typedefs

Enumerations

Functions

Detailed Description

Typedef Documentation

◆ Creator

◆ EntryPoint

◆ ImageHandle

◆ PPEB

◆ ProcessHandle

◆ ThreadHandle

Enumeration Type Documentation

◆ InfoType

◆ MemoryUnit

◆ ModuleType

◆ PR_file_type

◆ PR_search_type

◆ ProcessInfoCommand

◆ TimeType

Function Documentation

◆ accountName()

◆ adjustMemory()

◆ adjustTime() [1/2]

◆ adjustTime() [2/2]

◆ adjustTime< Day >()

◆ adjustTime< Hour >()

◆ adjustTime< microSec >()

◆ adjustTime< milliSec >()

◆ adjustTime< Min >()

◆ adjustTime< Month >()

◆ adjustTime< nanoSec >()

◆ adjustTime< Native >()

◆ adjustTime< Sec >()

◆ adjustTime< Year >()

◆ affinityMask()

◆ argc()

◆ argv()

◆ backTrace() [1/2]

◆ backTrace() [2/2]

◆ basePriority()

◆ breakExecution() [1/2]

◆ breakExecution() [2/2]

◆ cmdLineArgs()

◆ cpuTime()

◆ creationTime()

◆ currentTime() [1/3]

◆ currentTime() [2/3]

◆ currentTime() [3/3]

◆ currentTime< Day >()

◆ currentTime< Hour >()

◆ currentTime< microSec >()

◆ currentTime< milliSec >()

◆ currentTime< Min >()

◆ currentTime< Month >()

◆ currentTime< nanoSec >()

◆ currentTime< Native >()

◆ currentTime< Sec >()

◆ currentTime< Year >()

◆ ellapsedTime()

◆ exeHandle()

◆ exeName()

◆ exitStatus()

◆ getEnv() [1/4]

◆ getEnv() [2/4]

◆ getEnv() [3/4]

◆ getEnv() [4/4]

◆ getErrorString()

◆ getLastError()

◆ getLastErrorString()

◆ getProcedureByName() [1/2]

◆ getProcedureByName() [2/2]

◆ getProcess()

◆ getProcessTime()

◆ getStackLevel()

◆ homeDirectory()

◆ hostName()

◆ instructionsetLevel()

◆ isEnvSet()