managedInterface.h

Go to the documentation of this file.

/*********************************************************************************
** Copyright (c) 1992-2025 MAK Technologies, Inc.
** All rights reserved.
*********************************************************************************/

#pragma once


#include "managedInterface/delegate.h"
#include "managedInterface/plugin.h"

#include <vlutil/vlString.h>

#include <list>
#include <set>
#include <string>
#include <map>
 
class DtManagedInterface;
class DtMessage;
class DtMessageFactory;
class DtMessageHandler;
class DtLinkStrategy;
class DtFilePrinter;

typedef bool (*InitManagedInterfaceDllFunction)(DtManagedInterface* gl);
typedef void (*PluginVerisionFunction)(DtString& version);
typedef void (*PluginNameFunction)(DtString& name);
typedef DtLinkStrategy* (*StrategyCreator)(DtManagedInterface* gl);

typedef void (*ManagedMessageDelegate)(unsigned char* msg, int length);
typedef void (*JavaManagedMessageDelegate)(unsigned char* msg, int length, void* data);

enum DtProtocolType
{
   DtProtocolUnknown    = 0,
   DtProtocolDis        = 1,
   DtProtocolHLA13      = 2,
   DtProtocolHLA1516    = 3,
   DtProtocolHLA1516e   = 4,
   DtProtocolHLA4       = 5
};

class MANAGEDINTERFACE_DLL DtManagedInterface
{
   private:
      DtManagedInterface();
      virtual ~DtManagedInterface();
      
   public:
      static DtManagedInterface& instance();

      static bool exists();

      static void destroy();

      static bool checkVrlLicense();

      void initializeManagedInterface(ManagedMessageDelegate del);
      void initializeManagedInterface(JavaManagedMessageDelegate del, void* data, 
         unsigned char * reusableSendMsgBuffer);

      void tick(double maxTime);

      void shutdown();

      void receiveMessage(unsigned char* msg, int length);

      void sendMessage(DtMessage* msg);

      bool handleMessage(DtMessage* msg);

      virtual DtMessageFactory& messageFactory() const;

      //{@
      virtual bool hasResource(const std::string& name) const;
      
      virtual void* findResource(const std::string& name ) const;

      virtual void setResource(const std::string& name, void* asset);

      virtual bool removeResource(const std::string& name);

      //{@
      virtual void addHandler(const std::string& messageType, DtMessageDelegate* handler);
      virtual void removeHandler(const std::string& messageType, DtMessageDelegate* handler);

      //{@
      virtual void addStrategy(DtLinkStrategy* strategy);
      virtual void removeStrategy(const std::string& name);
      virtual DtLinkStrategy* findStrategy(const std::string& name);

      virtual void addStrategyCreator(const std::string& name, StrategyCreator creator);

      virtual DtLinkStrategy* createStrategy(const std::string& name);

      virtual double maxDrainInputTime() {return myMaxDrainInputTime;}

      virtual std::set<DtProtocolType> availableProtocols();

      virtual DtProtocolType activeProtocol();
      virtual void setActiveProtocol(DtProtocolType protocol);

   public:
      static std::string theDataPath;
      
   protected:
      virtual void handlePrintMessage(DtMessage* msg);
      virtual void handleNotifyLevelMessage(DtMessage* msg);
      virtual void prefixPath(const std::string &prefixDir) const;
      virtual void restorePath() const;
      virtual std::set<std::string> getPathDirs() const;
      virtual void loadLibsFromDir(const std::string &dirname, const std::set<std::string> &files, std::list<std::string>& filesLoaded);
      virtual std::set<std::string> findLibNames(const std::string &dirname, const std::string &filePrefix) const;
      virtual bool loadLibrary(const std::string &filename, const DtString &acceptableVersionStr);
      virtual bool loadCoreLibraries(const std::string &dirname, std::list<std::string>& filesLoaded);
      virtual void findAndLoadCoreLibraries(std::list<std::string>& filesLoaded);
      virtual void loadLibraries();
      virtual bool checkLibrariesLoaded(const std::list<std::string>& filesLoaded, std::set<DtProtocolType>& availableProtocol, bool shouldThrow = false);

      static DtManagedInterface* theInstance;

      DtProtocolType myActiveProtocol;
      ManagedMessageDelegate myCSharpMessageDelegate;
      
      JavaManagedMessageDelegate myJavaMessageDelegate;
      void* myData;
      unsigned char* myReusableSendBuffer;

      bool myIsInitalized;
      std::set<DtProtocolType> myInitializedProtocols;

      DtMessageFactory* myMessageFactory;

      typedef std::map<std::string, void*> ResourceMap;
      typedef ResourceMap::iterator ResourceIter;
      ResourceMap myResources;

      typedef std::multimap<std::string, DtMessageDelegate*> HandlerMap;
      typedef std::pair<std::string, DtMessageDelegate*> HandlerPair;
      HandlerMap myMessageHandlers;

      typedef std::map<std::string, DtLinkStrategy*> StrategyMap;
      typedef std::pair<std::string, DtLinkStrategy*> StrategyPair;
      StrategyMap myLinkStrategies;

      typedef std::map<std::string, StrategyCreator> StrategyCreatorMap;
      StrategyCreatorMap myStrategyCreatorMap;

      DtMessageDelegate* myPrintHandler;
      DtMessageDelegate* myNotifyLevelHandler;

      DtFilePrinter* myFilePrinter;
      std::set<std::string> myFilesLoaded;
      std::set<std::string> myPluginsLoaded;

      double myMaxDrainInputTime;

      static std::string restorePathStr;
};