managedInterface.h

Go to the documentation of this file.

/*********************************************************************************
** Copyright (c) 2014 MAK Technologies, Inc.
** All rights reserved.
*********************************************************************************/

#pragma once


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

#include <vlutil/vlString.h>

#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 DtLinkStrategy* (*StrategyCreator)(DtManagedInterface* gl);

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

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

      static bool exists();

      static void destroy();

      void initializeManagedInterface(ManagedMessageDelegate del);

      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(std::string name) const;
      
      virtual void* findResource(std::string name ) const;

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

      virtual bool removeResource(std::string name);

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

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

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

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

      virtual double maxDrainInputTime() {return myMaxDrainInputTime;}

   public:
      static std::string theDataPath;
      
   protected:
      virtual void handlePrintMessage(DtMessage* msg);
      virtual void handleNotifyLevelMessage(DtMessage* msg);
      virtual void loadLibraries();

      static DtManagedInterface* theInstance;

      ManagedMessageDelegate myCSharpMessageDelegate;

      bool myIsInitalized;

      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;

      double myMaxDrainInputTime;
};