vrfObjectReference.h

Go to the documentation of this file.

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

#pragma once

#include <vrfobjcore/vrfobjcoreDefines.h>
#include <vrfutil/rwString.h>
#include <vrfutil/rwUUID.h>
#include <vrfutil/rwTemplatedList.h>
#include <vrfutil/noArgumentCallbackList.h>
#include <vl/globalObjectDesignator.h>
#include <vlpi/entityIdentifier.h>
#include <boost/smart_ptr/shared_ptr.hpp>

#include <list>
#include <vector>

class DtVrfObjectDeletionTracker;
class DtVrfObject;
class DtVrfObjectManager;

typedef boost::shared_ptr<DtVrfObjectDeletionTracker> DtVrfObjectDeletionHandle;


class DT_DLL_vrfobjcore DtVrfObjectReference
{
public:
   DtVrfObjectReference();

   DtVrfObjectReference(DtVrfObject* object);
   DtVrfObjectReference(const DtString& objectNameToWaitFor);
   DtVrfObjectReference(const DtUUID& objectUUIDToWaitFor);
   DtVrfObjectReference(const DtRwUUID& objectUUIDToWaitFor);
   DtVrfObjectReference(const DtEntityIdentifier& objectUUIDToWaitFor);

   virtual ~DtVrfObjectReference();

   const DtVrfObject* object() const;
   DtVrfObject* object();

   operator DtVrfObject*() { return myObject; };
   operator const DtVrfObject* () const { return myObject; };

   virtual bool isValid() const;

   static void setVrfObjectManager(DtVrfObjectManager*);
   static DtVrfObjectManager* vrfObjectManager();

   virtual bool hasBeenDeleted() const;

   virtual const DtString& waitingForName() const;

   virtual void registerRemovedCallback();

   virtual DtUUID uuid() const;

   virtual void addObjectDiscoveredCallback(DtNoArgumentCallbackList::DtCallbackFunctionType, void* usr);
   virtual void removeObjectDiscoveredCallback(DtNoArgumentCallbackList::DtCallbackFunctionType, void* usr);

   virtual void addObjectAboutToBeRemovedCallback(DtNoArgumentCallbackList::DtCallbackFunctionType, void* usr);
   virtual void removeObjectAboutToBeRemovedCallback(DtNoArgumentCallbackList::DtCallbackFunctionType, void* usr);

protected:
   static void objectAddedCallback(DtVrfObject*, void*);
   virtual void processObjectAdded(DtVrfObject*);

   static void objectAboutToBeRemovedCallback(DtVrfObject*, void*);
   virtual void processObjectAboutToBeRemoved(DtVrfObject*);

private:
   DtVrfObjectReference(const DtVrfObjectReference&);
   DtVrfObjectReference& operator=(const DtVrfObjectReference&);

protected:
   DtVrfObject* myObject;
   DtString myWaitingForName;
   DtVrfObjectDeletionHandle myObjectDeletionHandle;
   DtNoArgumentCallbackList myObjectDiscoveredCallbacks;
   DtNoArgumentCallbackList myObjectAboutToBeRemovedCallbacks;
   bool myRemoveRegistered;

   static DtVrfObjectManager* theVrfObjectManager;
};

class DT_DLL_vrfobjcore DtSharedVrfObjectReference : public boost::shared_ptr<DtVrfObjectReference>
{
public:
   DtSharedVrfObjectReference() : boost::shared_ptr<DtVrfObjectReference>(new DtVrfObjectReference) {};
   DtSharedVrfObjectReference(DtVrfObjectReference* ref) : boost::shared_ptr<DtVrfObjectReference>(ref) {};
   DtSharedVrfObjectReference(const DtSharedVrfObjectReference& ref) : boost::shared_ptr<DtVrfObjectReference>(ref) {};

   DtSharedVrfObjectReference& operator=(const DtSharedVrfObjectReference& rhs)
   {
      boost::shared_ptr<DtVrfObjectReference>::operator=(rhs);

      return *this;
   }

   virtual ~DtSharedVrfObjectReference() {};

   virtual void addObjectDiscoveredCallback(DtNoArgumentCallbackList::DtCallbackFunctionType fcn, void* usr)
   {
      if (get()) { get()->addObjectDiscoveredCallback(fcn, usr); };
   }

   virtual void removeObjectDiscoveredCallback(DtNoArgumentCallbackList::DtCallbackFunctionType fcn, void* usr)
   {
      if (get()) { get()->removeObjectDiscoveredCallback(fcn, usr); };
   }

   virtual void addObjectAboutToBeRemovedCallback(DtNoArgumentCallbackList::DtCallbackFunctionType fcn, void* usr)
   {
      if (get()) { get()->addObjectAboutToBeRemovedCallback(fcn, usr); };
   }

   virtual void removeObjectAboutToBeRemovedCallback(DtNoArgumentCallbackList::DtCallbackFunctionType fcn, void* usr)
   {
      if (get()) { get()->removeObjectAboutToBeRemovedCallback(fcn, usr); };
   }

   bool hasBeenDeleted() const
   {
      if (get())
      {
         return get()->hasBeenDeleted();
      }

      return false;
   }

   bool isValid() const
   {
      if (get())
      {
         return get()->isValid();
      }

      return false;
   }

   DtString waitingForName() const
   {
      if (get())
      {
         return get()->waitingForName();
      }

      return "";
   }

   DtUUID uuid() const
   {
      if (get())
      {
         return get()->uuid();
      }
      else
      {
         return DtUUID(waitingForName());
      }
   }

   DtVrfObject* operator->() { if (get() && get()->isValid()) return get()->object(); else return 0; };
   const DtVrfObject* operator->() const { if (get() && get()->isValid()) return get()->object(); else return 0; };

   operator DtVrfObject*() { if (get() && get()->isValid()) return get()->object(); else return 0; };
   operator const DtVrfObject* () const { if (get() && get()->isValid()) return get()->object(); else return 0; };

   const DtVrfObject* operator*() const { if (get() && get()->isValid()) return get()->object(); else return 0; };
   DtVrfObject* operator*() { if (get() && get()->isValid()) return get()->object(); else return 0; };
   bool operator!() { if (get()) { return !get()->isValid(); } return true; };
};


class DT_DLL_vrfobjcore DtRwVrfObjectReference : public DtRwUUID
{
public:
   DtRwVrfObjectReference();

   DtRwVrfObjectReference(const DtString& name, DtReaderWriterRegistry* 
      parentRegistry = NULL);

   DtRwVrfObjectReference(const DtSymbolString& name, DtReaderWriterRegistry* 
      parentRegistry = NULL);

   DtRwVrfObjectReference(const DtString&, const DtUUID&,
      DtReaderWriterRegistry* parentRegistry = NULL);

   DtRwVrfObjectReference(const DtSymbolString&, const DtUUID&,
      DtReaderWriterRegistry* parentRegistry = NULL);

   DtRwVrfObjectReference(const DtString&, const DtRwUUID&,
      DtReaderWriterRegistry* parentRegistry = NULL);

   DtRwVrfObjectReference(const DtSymbolString&, const DtRwUUID&,
      DtReaderWriterRegistry* parentRegistry = NULL);

   DtRwVrfObjectReference(const DtRwVrfObjectReference&,
      DtReaderWriterRegistry* parentRegistry = NULL);

   virtual ~DtRwVrfObjectReference();

   virtual void setUUID(const DtUUID&);

   virtual bool isValid() const;
   virtual bool hasBeenDeleted() const;

   virtual const DtVrfObject* object() const;
   virtual DtVrfObject* object();

   operator DtVrfObject*() { return object(); };
   operator const DtVrfObject* () const { return object(); };

   virtual void addObjectDiscoveredCallback(DtNoArgumentCallbackList::DtCallbackFunctionType, void* usr);
   virtual void removeObjectDiscoveredCallback(DtNoArgumentCallbackList::DtCallbackFunctionType, void* usr);

   virtual void addObjectAboutToBeRemovedCallback(DtNoArgumentCallbackList::DtCallbackFunctionType, void* usr);
   virtual void removeObjectAboutToBeRemovedCallback(DtNoArgumentCallbackList::DtCallbackFunctionType, void* usr);

   virtual void setObjectReference(DtSharedVrfObjectReference);
   DtRwVrfObjectReference& operator=(const DtRwVrfObjectReference&);
   DtRwVrfObjectReference& operator=(const DtSharedVrfObjectReference&);

   virtual void clearObjectReference();

   DtVrfObject* operator->();
   const DtVrfObject* operator->() const;

   operator const DtUUID&() const { return uuid(); };
   virtual DtEntityIdentifier entityIdentifier() const;
   virtual DtGlobalObjectDesignator globalObjectDesignator() const;

   DtSharedVrfObjectReference objectReference();
   DtSharedVrfObjectReference objectReference() const;

   virtual void clearUUID();

   virtual void getSelf(DtlObjPtr args, 
      const DtReaderWriter::SearchPaths& searchPaths = SearchPaths(), 
      const DtVariableBindingsList& variableBindings = nullVariableReference());

   virtual void putSelf(FILE* fp, int indentLevel = 0, 
      bool writeUnspecified = false, const DtFilename& path = 
      DtFilename::nullFilename());

protected:
   static void objectDiscoveredCallback(void* usr);
   virtual void processObjectDiscovered();

   static void objectAboutToBeRemovedCallback(void* usr);
   virtual void processObjectAboutToBeRemoved();

   virtual void uuidChanged();

protected:
   DtSharedVrfObjectReference myObject;
   bool myAddedRemovedCallback;
};


class DT_DLL_vrfobjcore DtRwVrfObjectReferenceList : public DtRwTemplatedListPtr<DtRwVrfObjectReference, true>
{
public:
   DtRwVrfObjectReferenceList();

   DtRwVrfObjectReferenceList(const DtString& name, DtReaderWriterRegistry* parentRegistry = NULL);
   DtRwVrfObjectReferenceList(const DtSymbolString& name, DtReaderWriterRegistry* parentRegistry = NULL);

   DtRwVrfObjectReferenceList(const DtString& name,  const DtRwVrfObjectReferenceList& orig, 
      DtReaderWriterRegistry* parentRegistry = NULL);

   DtRwVrfObjectReferenceList(const DtSymbolString& name,  const DtRwVrfObjectReferenceList& orig, 
      DtReaderWriterRegistry* parentRegistry = NULL);

   DtRwVrfObjectReferenceList(const DtRwVrfObjectReferenceList& orig, 
      DtReaderWriterRegistry* parentRegistry = NULL);

   virtual ~DtRwVrfObjectReferenceList();

   virtual DtVrfObject* findUUID(const DtUUID&);
   virtual const DtVrfObject* findUUID(const DtUUID&) const;

   virtual void addUUID(const DtUUID&);

   virtual bool removeUUID(const DtUUID&);

   virtual bool hasUUID(const DtUUID&) const;

   virtual std::vector<DtRwUUID> uuidsAsVector() const;

   virtual std::list<DtRwUUID> uuidsAsList() const;

   static void objectAboutToBeRemoved(DtVrfObject*, void*);
   virtual void processObjectAboutToBeRemoved(DtVrfObject*);
};