rtiUtil.h

Go to the documentation of this file.

/*********************************************************************
** Copyright (c) 2003 MaK Technologies, Inc.
** All rights reserved.
*********************************************************************/
/*********************************************************************
** $RCSfile: rtiUtil.h,v $ $Revision: 1.23 $ $State: Exp $
*********************************************************************/


#ifndef DtRtiUtil_H_
#define DtRtiUtil_H_

#include "rtiMsConfig.h"

#include <set>
#include <map>
#include <algorithm>
#include <utility>
#include <vector>

#include <vlutil/vlPrint.h>
#include <vlutil/vlFilename.h>
#include <vlutil/vlUtil.h>
#include <vlutil/vlPrint.h>
#include <vlutil/vlExceptions.h>
#include <vlutil/vlString.h>
#include <vlutil/vlInetAddr.h>

#ifndef _WIN32
#ifndef __sgi__
#ifndef __solaris__
#include <netinet/if_ether.h>
#include <net/if.h>
#endif
#endif
#endif

#define MAKRTI_MT
namespace MAKRti
{
   class DtClock;
}

#ifdef MAKRTI_MT
#define MAK_STATIC
#else
#define MAK_STATIC static
#endif

const unsigned int DtGreatestValidPortNumber = 65535;

DT_DLL_RTIUTIL void DtRtiAttachNotificationPrinter( MAKRti::DtNotifyLevelType level, MAKRti::DtPrinter* printer );

DT_DLL_RTIUTIL void DtRtiDetachNotificationPrinter( MAKRti::DtNotifyLevelType level, MAKRti::DtPrinter* printer );

DT_DLL_RTIUTIL MAKRti::DtFilename DtRtiSearchPathList( const MAKRti::DtFilename& libName, 
                                                       const MAKRti::DtString& searchPath = "" );

DT_DLL_RTIUTIL MAKRti::DtFilename DtRtiLibPath(const MAKRti::DtString& searchPath = "");

DT_DLL_RTIUTIL MAKRti::DtString& DtMakeFileNameUnique(MAKRti::DtString& fileName);

DT_DLL_RTIUTIL MAKRti::DtFilename& DtResolveAbsoluteFileLocation(const MAKRti::DtString& path,
   const MAKRti::DtString& fileName, MAKRti::DtFilename& resolvedFilePath);

DT_DLL_RTIUTIL MAKRti::DtFilename& DtMakeLogFilePath(const MAKRti::DtString& baseFilePath,
   const MAKRti::DtString& fileName, bool makeUnique, MAKRti::DtFilename& resolvedFilePath);

DT_DLL_RTIUTIL MAKRti::DtString DtGetProcessName();

DT_DLL_RTIUTIL bool DtLocateConfigFile(MAKRti::DtFilename const& fileName, MAKRti::DtFilename& locatedFileName);

DT_DLL_RTIUTIL bool DtNonBlockingPollInputLine(MAKRti::DtString& buffer);


DT_DLL_RTIUTIL int DtGetKey();

DT_DLL_RTIUTIL int DtKBHit();

DT_DLL_RTIUTIL void DtSetNotifyLevel(unsigned int notifyLevel);

DT_DLL_RTIUTIL bool DtReadFile( FILE* fileHandle,
                             char** fileBuffer, unsigned int* fileSize);

DT_DLL_RTIUTIL int DtBitsRequiredToRepresent(unsigned long x);


DT_DLL_RTIUTIL const MAKRti::DtString& DtGetLocalHostName();

DT_DLL_RTIUTIL void DtGetLocalHostName(MAKRti::DtString& hostName, bool onlyFillIfEmpty = true);

DT_DLL_RTIUTIL MAKRti::DtString DtPerformDNSLookup(MAKRti::DtInetAddr addr);

DT_DLL_RTIUTIL MAKRti::DtException const& DtInitialException(MAKRti::DtException const& ex);

DT_DLL_RTIUTIL MAKRti::DtOutputStream& DtRtiOutputStream( MAKRti::DtNotifyLevelType level );

typedef std::pair< MAKRti::DtInetAddr, int > DtInetAddrAndPort;

DT_DLL_RTIUTIL MAKRti::DtString addrAndPortToString(const DtInetAddrAndPort& addrPort);

#ifdef _WIN32
DT_DLL_RTIUTIL void getRegKey( MAKRti::DtString& val, HKEY rootKey, 
                              const MAKRti::DtString& keyPath, const MAKRti::DtString& keyName );
DT_DLL_RTIUTIL void setRegKey( const MAKRti::DtString& keyVal, HKEY rootKey, 
                              const MAKRti::DtString& keyPath, const MAKRti::DtString& keyName, 
                              bool expand );
DT_DLL_RTIUTIL void removeRegKey( HKEY rootKey, const MAKRti::DtString& keyPath, 
                                 const MAKRti::DtString& keyName );

DT_DLL_RTIUTIL void setEnvVar( const MAKRti::DtString &val, const MAKRti::DtString& name,  
                       bool isSystem, bool expand ) ;
DT_DLL_RTIUTIL void getEnvVar( MAKRti::DtString& val, const MAKRti::DtString& name, bool isSystem );
DT_DLL_RTIUTIL void removeEnvVar( const MAKRti::DtString& name, bool isSystem );

DT_DLL_RTIUTIL void expandEnvVar(MAKRti::DtString& outVar );
DT_DLL_RTIUTIL bool canWriteSystemPath();
DT_DLL_RTIUTIL bool canWriteUserPath();



DT_DLL_RTIUTIL MAKRti::DtString getAssistantRegistryString();
DT_DLL_RTIUTIL void getSystemRunLocation(HKEY& rootKey, MAKRti::DtString& regPath);
DT_DLL_RTIUTIL void getUserRunLocation(HKEY& rootKey, MAKRti::DtString& regPath);
#endif

DT_DLL_RTIUTIL void shutdownAssistant(bool force
#ifdef _WIN32 
                                      , std::pair< void*, void* > & resultInfo );
#else
                                      );
#endif
DT_DLL_RTIUTIL void startupAssistant();

enum DtRtiAssistantCommandEnum
{
   DtAssistantCommandList,
   DtAssistantCommandListRtiExec,
   DtAssistantCommandListForwarder,
   DtAssistantCommandKill,
   DtAssistantCommandDeleteFederate
};

struct DtRtiAssistantCommand
{
   DtRtiAssistantCommandEnum commType;
   int assistantHandle;
   int targetFedexHandle;
   int targetFederateHandle;
};

enum DtRtiAssistantStartupRequest 
{ 
   DtAssistantStartupNoChange, 
   DtAssistantStartupInstallUser,
   DtAssistantStartupInstallSys,
   DtAssistantStartupUninstall 
};

DT_DLL_RTIUTIL bool changeAssistantStartup(DtRtiAssistantStartupRequest desiredState);
DT_DLL_RTIUTIL bool removeAssistantStartup();
DT_DLL_RTIUTIL void queryAssistantStartup( bool& isStartupItem, bool& isUserStartupItem );


#define DtRtiFatal DtRtiOutputStream( MAKRti::DtNlFatal )
#define DtRtiWarn DtRtiOutputStream( MAKRti::DtNlWarn )
#define DtRtiInfo DtRtiOutputStream( MAKRti::DtNlInfo )
#define DtRtiVerbose DtRtiOutputStream( MAKRti::DtNlVerbose )
#define DtRtiDebug DtRtiOutputStream( MAKRti::DtNlDebug )

#define DtIsMember(container, element) (container.find(element) != container.end())

template<class T> void DtDeletePointerContainer(T& pointerContainer)
{
   typename T::iterator iter = pointerContainer.begin();
   typename T::iterator theEnd = pointerContainer.end();
   for (; iter != theEnd; ++iter)
   {
      delete *iter;
   }

   pointerContainer.clear();
}


template<class T> class DtDeepCopyPointerVector
{
private:
   std::vector<T*>& myVector;
public:
   DtDeepCopyPointerVector(std::vector<T*>& targetVector) : myVector(targetVector)
   {
      DtDeletePointerContainer(myVector);
   }

   void operator() (T* element)
   {
      if (!element)
      {
         myVector.push_back(element);
      }
      else
      {
         myVector.push_back(new T(*element));
      }
   }
};

template<class T> class DtDeepCopyPointerSet
{
private:
   std::set<T*>& mySet;
public:
   DtDeepCopyPointerSet(std::set<T*>& targetSet) : mySet(targetSet)
   {
      DtDeletePointerContainer(mySet);
   }

   void operator() (T* element)
   {
      if (!element)
      {
         mySet.insert(element);
      }
      else
      {
         mySet.insert(new T(*element));
      }
   }
};

template<class T> void DtDeleteByPointerMap(T& byPointerMap)
{
   typename T::iterator iter = byPointerMap.begin();
   typename T::const_iter theEnd = byPointerMap.end();
   for (; iter != theEnd; ++iter)
   {
      delete iter->first;
   }
   byPointerMap.clear();
}

template<class T, class Y> class DtDeepCopyByPointerMap
{
private:
   std::map<T*, Y>& myMap;
public:
   DtDeepCopyByPointerMap(std::map<T*, Y>& targetMap) : myMap(targetMap)
   {
      DtDeleteByPointerMap(myMap);
   }

   void operator() (const std::pair<T* const, Y> element)
   {
      if (!element.first)
      {
         myMap.insert(element);
      }
      else
      {
         myMap.insert(std::make_pair(new T(*element.first), element.second));
      }
   }
};

template<class T> void DtDeleteToPointerMap(T& pointerMap)
{
   typename T::iterator iter = pointerMap.begin();
   typename T::const_iterator theEnd = pointerMap.end();
   for (; iter != theEnd; ++iter)
   {
      delete iter->second;
   }
   pointerMap.clear();
}

template<class T, class Y> class DtDeepCopyToPointerMap
{
private:
   std::map<T, Y*>& myMap;
public:
   DtDeepCopyToPointerMap(std::map<T, Y*>& targetMap) : myMap(targetMap)
   {
      DtDeleteToPointerMap(targetMap);
   }

   void operator() (const std::pair<T, Y* const> element)
   {
      if (!element.second)
      {
         myMap.insert(element);
      }
      else
      {
         myMap.insert(std::make_pair(element.first, new Y(*element.second)));
      }
   }
};

// The links between a source key map to elements in a target key map
// are reconstructed in the target map to the source map
template<class TargetKeyType, class SourceKeyType, class T> class DtSourceKeyToTargetKeyLinkReconstructor
{
private:
   std::map<TargetKeyType, T*>& myTargetMap;
   std::map<SourceKeyType, T*> const& mySourceMap;

public:
   // Constructor
   DtSourceKeyToTargetKeyLinkReconstructor(
      std::map<TargetKeyType, T*>& targetMap,
      std::map<SourceKeyType, T*> const& sourceMap)
      : myTargetMap(targetMap)
      , mySourceMap(sourceMap)
   {}

   // Function operator
   void operator() (std::pair<TargetKeyType, T*> element)
   {
      if (!element.second)
      {
         myTargetMap[element.first] = 0;
      }
      else
      {
         typename std::map<SourceKeyType, T*>::const_iterator findIter = mySourceMap.find(element.second->handle());
         if (findIter != mySourceMap.end())
         {
            myTargetMap[element.first] = findIter->second;
         }
      }
   }
};

template <class T, class Thandle> void DtAdjustHandles(T* info, std::map<Thandle, T*>& byHandle,
   std::map<MAKRti::DtString, T*>& byName)
{
   // Walk backwards from end of name map until just past info's position,
   // swapping handle values and reinserting into byHandle map along the way.
   // Start at end of byName map using info's handle which is the highest value.
   typename std::map<MAKRti::DtString, T*>::reverse_iterator rClassIter = byName.rbegin();
   Thandle handleReplacement = info->handle();

   // Stopping position is the iterator before the inserted info
   typename std::map<MAKRti::DtString, T*>::iterator findIter = byName.find(info->name());
   typename std::map<MAKRti::DtString, T*>::reverse_iterator rClassEnd(findIter);

   for (; rClassIter != rClassEnd; ++rClassIter)
   {
      Thandle thisHandle = rClassIter->second->handle();
      rClassIter->second->setHandle(handleReplacement);
      byHandle[handleReplacement] = rClassIter->second;
      handleReplacement = thisHandle;
   }
}

template <class T, class Thandle> void DtAdjustOwnHandles(T* info, std::map<Thandle, T*>& byHandle,
   std::map<Thandle, T*>& ownByHandle, std::map<MAKRti::DtString, T*>& byName)
{
   // Walk backwards from end of name map until just past info's position,
   // swapping handle values and reinserting into byHandle map along the way.
   // Start at end of byName map using info's handle which is the highest value.
   typename std::map<MAKRti::DtString, T*>::reverse_iterator rClassIter = byName.rbegin();
   Thandle handleReplacement = info->handle();

   // Stopping position is the iterator before the inserted info
   typename std::map<MAKRti::DtString, T*>::iterator findIter = byName.find(info->name());
   typename std::map<MAKRti::DtString, T*>::reverse_iterator rClassEnd(findIter);

   for (; rClassIter != rClassEnd; ++rClassIter)
   {
      Thandle thisHandle = rClassIter->second->handle();
      rClassIter->second->setHandle(handleReplacement);
      byHandle[handleReplacement] = rClassIter->second;
      ownByHandle[handleReplacement] = rClassIter->second;
      handleReplacement = thisHandle;
   }
}

template< typename T, typename TContainer >
bool DtUNIQUE_INSERT( const T& value, TContainer& container )
{
   typename TContainer::iterator pos = std::find( container.begin(), container.end(), value );
   if ( pos != container.end() )
   {
      return false;
   }
   else
   {
      container.insert( pos, value );
      return true;
   }
};

#ifdef DtTHROW_PROPAGATE
#undef DtTHROW_PROPAGATE
#endif
#define DtTHROW_PROPAGATE(exceptionClass,errorMsg, exPtr) \
   throw exceptionClass(MAKRti::DtString(#exceptionClass": ") + errorMsg, __DtFUNC__, MAKRti::DtFilename::stripPath(__FILE__), __LINE__, exPtr)

enum DtRtiExceptionDesignator
{
   DtRtiExceptionDesignatorDefault,
   DtRtiExceptionDesignatorPopup,
   DtRtiExceptionDesignatorInvalidRidExpression
};

typedef MAKRti::DtTemplatedException<DtRtiExceptionDesignatorDefault> DtRtiException;
typedef MAKRti::DtTemplatedException<DtRtiExceptionDesignatorPopup>   DtRtiExceptionPopup;
typedef MAKRti::DtTemplatedException<DtRtiExceptionDesignatorInvalidRidExpression>   DtRtiExceptionInvalidRidExpression;

DT_DLL_RTIUTIL typedef std::set<MAKRti::DtInetAddr> DtInetAddrSet;

DT_DLL_RTIUTIL MAKRti::DtInetAddr DtDefaultInterfaceAddr();

#ifndef __solaris__
#ifndef __sgi__
DT_DLL_RTIUTIL int DtEnumerateInterfaces(std::vector<MAKRti::DtInetAddr>& addresses,
                                         bool ignoreLoopback);
DT_DLL_RTIUTIL bool DtIsIpOfLocalInterface(const MAKRti::DtInetAddr& addrInQuestion, bool refresh = false);
#endif // sgi
#endif // solaris

DT_DLL_RTIUTIL unsigned long long DtFirstHostMACAddr();

DT_DLL_RTIUTIL MAKRti::DtString timeString(const MAKRti::DtClock& clock);

DT_DLL_RTIUTIL MAKRti::DtString timeString();

DT_DLL_RTIUTIL void writeMessageToStdErrPipe(const MAKRti::DtString& msg);


#endif