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


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

int DtBitsRequiredToRepresent(unsigned long x);


DT_DLL_RTIUTIL const MAKRti::DtString& DtGetLocalHostName();

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;

#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 DtDeleteVectorOfPointers(T& pointerVector)
{
   typename T::iterator iter = pointerVector.begin();
   while (iter != pointerVector.end())
   {
      delete *iter;
      iter = pointerVector.erase(iter);
   }
}

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

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


template<class T> void DtDeleteSetOfPointers(T& pointerSet)
{
   typename T::iterator iter = pointerSet.begin();
   while (iter != pointerSet.end())
   {
      delete *iter;
      pointerSet.erase(iter);
      iter = pointerSet.begin();      
   }
}



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

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


template<class T, class Y> class DtDeepCopyPointerIntoMap
{
private:
   std::map<T*, Y>& myMap;
public:
   DtDeepCopyPointerIntoMap(std::map<T*, Y>& targetMap) : myMap(targetMap)
   {
      typename std::map<T*, Y>::iterator iter = myMap.begin();
      typename std::map<T*, Y>::iterator theEnd = myMap.end();
      for ( ; iter != theEnd; ++iter )
      {
         delete iter->first;
      }
      myMap.clear();
   }

   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< 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 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();




#endif