subordinateManagerStateComponent.h

Go to the documentation of this file.

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

#pragma once

#include "vrfStateData/vrfStateDataDefines.h"
#include "vrfStateData/stateComponent.h"
#include "vrfStateData/doubleBufferedDataStorage.h"
#include <vrfutil/rwUUID.h>

namespace makVrf
{
   struct DT_DLL_vrfStateData DtSubordinateManagerStateComponentData
   {
      DtSubordinateManagerStateComponentData()
      {}

      DtSubordinateManagerStateComponentData(const DtSubordinateManagerStateComponentData& orig)
      : mySubordinates(orig.mySubordinates)
      {
      }

      DtSubordinateManagerStateComponentData& operator=(const DtSubordinateManagerStateComponentData& rhs)
      {
         mySubordinates = rhs.mySubordinates;

         return *this;
      }

      DEFINE_ACCESSOR_MUTATOR(std::vector<DtUUID>, subordinates, Subordinates);
      void addSubordinate(const DtUUID& uuid, int index = -1)
      {
         if (index == -1)
         {
            mySubordinates.push_back(uuid);
         }
         else
         {
            if (index >= mySubordinates.size())
            {
               while (mySubordinates.size() <= index)
               {
                  mySubordinates.push_back(DtUUID::nullUUID());
               }
            }

            mySubordinates[index] = uuid;
         }
      };
      bool removeSubordinate(const DtUUID& uuid)
      {
         std::vector<DtUUID>::iterator iter = mySubordinates.begin();
         std::vector<DtUUID>::iterator end = mySubordinates.end();

         while (iter != end)
         {
            if (*iter == uuid)
            {
               mySubordinates.erase(iter);
               return true;
            }

            ++iter;
         }

         return false;
      }

      void removeAllSubordinates() { mySubordinates.clear(); };
      bool hasSubordinate(const DtUUID& uuid) const
      {
         std::vector<DtUUID>::const_iterator iter = mySubordinates.begin();
         std::vector<DtUUID>::const_iterator end = mySubordinates.end();

         while (iter != end)
         {
            if (*iter == uuid)
            {
               return true;
            }

            ++iter;
         }

         return false;
      }

      const DtUUID& firstSubordinate() const
      {
         if (mySubordinates.size())
         {
            return mySubordinates[0];
         }

         return DtUUID::nullUUID();
      }

      const DtUUID& lastSubordinate() const
      {
         if (mySubordinates.size())
         {
            return mySubordinates[mySubordinates.size() - 1];
         }

         return DtUUID::nullUUID();
      }

   protected:
      std::vector<DtUUID> mySubordinates;
   };

   class DT_DLL_vrfStateData DtSubordinateManagerStateComponent : public DtFrameStateInterface
   {
   public:
      DEFINE_STATE_COMPONENT_TYPE(DtStateComponent::SubordinateManagerStateComponent)

      DtSubordinateManagerStateComponent(DtStateData* storage)
      : DtFrameStateInterface(storage)
      {
      }

      UNDEFINED_RETURNREF_ACCESSOR_MUTATOR(std::vector<DtUUID>, subordinates, Subordinates)
      UNDEFINED_METHOD(void, addSubordinate, const DtUUID&, int index = -1)
      UNDEFINED_METHOD(bool, removeSubordinate, const DtUUID&)
      UNDEFINED_METHOD(void, removeAllSubordinates)
      UNDEFINED_RETURNREF_ACCESSOR(DtUUID, firstSubordinate)
      UNDEFINED_RETURNREF_ACCESSOR(DtUUID, lastSubordinate)
      virtual int numSubordinates() const { throw DtUnimplementedMethod("The int numSubordinates() const is undefined for this class."); }; 
      virtual bool hasSubordinate(const DtUUID&) const { throw DtUnimplementedMethod("The bool hasSubordinate(const DtUUID&) const is undefined for this class."); }; 

      mutable boost::signals2::signal<void (const DtFrameStateInterface*, const std::vector<DtUUID>& oldSubordinates, const std::vector<DtUUID>& newSubordinates)> signal_subordinatesChanged;
   };

   class DT_DLL_vrfStateData DtSubordinateManagerStateComponentNextFrame : public DtSubordinateManagerStateComponent
   {
   public:
      DtSubordinateManagerStateComponentNextFrame(DtStateData* storage);

      const DtSubordinateManagerStateComponentData& frameState() const { return myData; };
      DtSubordinateManagerStateComponentData& frameState() { return myData; };

      int numSubordinates() const;
      const DtUUID& firstSubordinate() const;
      const DtUUID& lastSubordinate() const;
      const std::vector<DtUUID>& subordinates() const;
      void setSubordinates(const std::vector<DtUUID>&);
      void addSubordinate(const DtUUID&, int index = -1);
      bool removeSubordinate(const DtUUID&);
      bool hasSubordinate(const DtUUID&) const;
      void removeAllSubordinates();

      virtual void makeWritable() {};

      virtual void makeReadOnly() {};

   protected:
      DtSubordinateManagerStateComponentData myData;
   };

   class DT_DLL_vrfStateData DtSubordinateManagerStateComponentCurrentFrame : public DtSubordinateManagerStateComponent
   {
   public:
      DtSubordinateManagerStateComponentCurrentFrame(DtStateData* storage);

      const DtSubordinateManagerStateComponentData& frameState() const { return myData; };

      const DtUUID& firstSubordinate() const;
      const DtUUID& lastSubordinate() const;
      int numSubordinates() const;
      const std::vector<DtUUID>& subordinates() const;
      bool hasSubordinate(const DtUUID&) const;

   protected:
      friend class DtSubordinateManagerStateComponentImplementation;
      void advanceFrame(const DtSubordinateManagerStateComponentData& data)
      {
         myData = data;
      }

   protected:
      DtSubordinateManagerStateComponentData myData;
   };

   class DT_DLL_vrfStateData DtSubordinateManagerStateComponentImplementation : public DtDoubleBufferedStateComponent<DtSubordinateManagerStateComponent>
   {
   public:
      DtSubordinateManagerStateComponentImplementation(DtStateData* sd);

      bool isDoubleBuffered() { return true; };
      const DtFrameStateInterface* currentFrameState() const { return &myCurrentFrameState; }
      virtual DtFrameStateInterface* nextFrameState() { return &myNextFrameState; };
      virtual const DtFrameStateInterface* nextFrameState() const { return &myNextFrameState; };

      void updateDataStorage();

      void updateStateData(DtStateData* sd)
      {
         myCurrentFrameState.updateStateData(sd);
         myNextFrameState.updateStateData(sd);
      }

      virtual void aboutToBeDeleted() override
      {
         DtDoubleBufferedStateComponent<DtSubordinateManagerStateComponent>::aboutToBeDeleted();
         myCurrentFrameState.aboutToBeDeleted();
         myNextFrameState.aboutToBeDeleted();
      }

   protected:
      DtSubordinateManagerStateComponentCurrentFrame myCurrentFrameState;
      DtSubordinateManagerStateComponentNextFrame myNextFrameState;
      std::vector<DtUUID> mySubordinates;
   };

   typedef DtStateComponentCreator<DtSubordinateManagerStateComponentImplementation> DtSubordinateManagerStateComponentCreator;
}