tAmoInterface.h

Go to the documentation of this file.

//********************************************************************
//********************************************************************
//********************************************************************
//********************************************************************
#ifndef tAmoInterface_H_
#define tAmoInterface_H_


#if DtTENA

#include "coLromMapExport.h"
#include <vlutil/vlMachineTypes.h>
#include <vl/tObjectInterface.h>
#include <vl/amoSR.h>
#include <vl/globalObjDes.h>

#include <TENA/AMO/ServantPtr.h>
#include <TENA/AMO/ProxyPtr.h>
#include <TENA/AMO/ImmutablePublicationStatePtr.h>
#include <TENA/AMO/SubscriptionInfoPtr.h>
#include <TENA/UniqueID/Includes.h>

#include <map>
#include <list>

class DT_DLL_COMMONLROM DtAmoInterface: public DtObjectInterface
{
protected:

   class DtAmoServantObject : public DtTenaServantObject
   {
   public:
      DtAmoServantObject( TENA::AMO::ServantPtr sp):myServantPtr(sp){}
      
      virtual ~DtAmoServantObject() {}

      virtual const TENA::AMO::ServantPtr servant() const { return myServantPtr;}
      
      virtual TENA::AMO::ServantPtr servant() { return myServantPtr;}

   protected:
       TENA::AMO::ServantPtr myServantPtr;
   };

public:
   DtAmoInterface(DtExerciseConn* exConn);

   virtual ~DtAmoInterface();

private:
   DtAmoInterface(const DtAmoInterface &other);

   DtAmoInterface& operator=(const DtAmoInterface &other);

public:

   virtual DtTenaServantObject* createServantObject(DtExerciseConn* exConn);
   
   virtual void processServantCleanup(DtTenaServantObject* servantObject);

   virtual void subscribe();

   virtual bool needUpdate(const DtStateRepository& stateRep, 
                           const DtStateRepository& asSeenByRemote,
                           bool useThresholding = true);

   virtual void decode(const DtTenaServantObject* servant,
                       DtStateRepository* stateRep)const;

   virtual void encode(DtTenaServantObject* servant, 
                       const DtStateRepository* stateRep,
                       TENA::Time::Pointer timeForStamping,
                       bool forceUpdate = false);

   virtual DtReflectedObject *createReflectedObject()const;

   virtual void processAddition(TENA::AMO::ProxyPtr const &proxy);
   
   virtual void processUpdate(TENA::AMO::ProxyPtr const &proxy);
   
   virtual void processRemoval(TENA::AMO::ProxyPtr const &proxy);


protected:
   virtual void decode(const TENA::AMO::ImmutablePublicationStatePtr pubStatePtr,
                       DtStateRepository* stateRep)const;

protected:

   TENA::AMO::SubscriptionInfoPtr mySubscriptionInfoPtr;
   typedef std::map<TENA::AMO::ProxyPtr, DtReflectedObject *> ProxyToRefObjMap;
   ProxyToRefObjMap myRefAmoMap;
   ProxyToRefObjMap myAmoWaitList;
};


#endif
#endif