aisDataStateComponent.h

Go to the documentation of this file.

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

#pragma once

#include "vrfStateData/stateComponent.h"
#include "vrfStateData/doubleBufferedDataStorage.h"
#include "legionDataStore/writeStateInstance.h"

#include <vlutil/vlString.h>

namespace makVrf
{
    struct DtAisDataStateComponentData
    {
        DtAisDataStateComponentData()
            : myMmsi(0)
            , myImo(0)
            , myEta(0)
            , myStatus(0)
            , myDestination()
        {};

        DtAisDataStateComponentData(const DtAisDataStateComponentData& orig)
        {
            myMmsi = orig.myMmsi;
            myImo = orig.myImo;
            myEta = orig.myEta;
            myStatus = orig.myStatus;
            myDestination = orig.myDestination;
        }

        DtAisDataStateComponentData& operator=(const DtAisDataStateComponentData& orig)
        {
            myMmsi = orig.myMmsi;
            myImo = orig.myImo;
            myEta = orig.myEta;
            myStatus = orig.myStatus;
            myDestination = orig.myDestination;

            return *this;
        }

        DEFINE_ACCESSOR_MUTATOR(int, mmsi, Mmsi)
        DEFINE_ACCESSOR_MUTATOR(int, imo, Imo)
        DEFINE_ACCESSOR_MUTATOR(int, eta, Eta)
        DEFINE_ACCESSOR_MUTATOR(int, status, Status)
        DEFINE_ACCESSOR_MUTATOR(DtString, destination, Destination)

    protected:
        int myMmsi;
        int myImo;
        int myEta;
        int myStatus;
        DtString myDestination;
    };

   class DT_DLL_vrfStateData DtAisDataStateComponent : public DtFrameStateInterface
   {
   public:
      DEFINE_STATE_COMPONENT_TYPE(DtStateComponent::AisDataStateComponent)

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

      UNDEFINED_RETURNVALUE_ACCESSOR_MUTATOR(int, mmsi, Mmsi)
      UNDEFINED_RETURNVALUE_ACCESSOR_MUTATOR(int, imo, Imo)
      UNDEFINED_RETURNVALUE_ACCESSOR_MUTATOR(int, eta, Eta)
      UNDEFINED_RETURNVALUE_ACCESSOR_MUTATOR(DtString, destination, Destination)
      UNDEFINED_RETURNVALUE_ACCESSOR_MUTATOR(int, status, Status)

   };

   class DT_DLL_vrfStateData DtAisDataStateComponentNextFrame : public DtAisDataStateComponent
   {
   public:
       DtAisDataStateComponentNextFrame( DtStateData*);
      virtual ~DtAisDataStateComponentNextFrame();

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

      const int mmsi() const;
      void setMmsi(const int&);

      const int imo() const;
      void setImo(const int&);
      
      const int eta() const;
      void setEta(const int&);

      const DtString destination() const;
      void setDestination(const DtString&);

      const int status() const;
      void setStatus(const int&);

      virtual void makeWritable() {};

      virtual void makeReadOnly() {};


   protected:
      DtStateData* myStateData;
      mutable DtAisDataStateComponentData myData;
   };

   class DT_DLL_vrfStateData DtAisDataStateComponentCurrentFrame : public DtAisDataStateComponent
   {
   public:

       DtAisDataStateComponentCurrentFrame(DtStateData*);
       virtual ~DtAisDataStateComponentCurrentFrame();

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

       const int mmsi() const;
       const int imo() const;
       const int eta() const;
       const DtString destination() const;
       const int status() const;

       friend class DtAisDataStateImplementation;
       void advanceFrame(const DtAisDataStateComponentData& data)
       {
           myData = data;
       }

   protected:
      DtStateData* myStateData;
      DtAisDataStateComponentData myData;
   };

   class DT_DLL_vrfStateData DtAisDataStateComponentImplementation : public DtDoubleBufferedStateComponent<DtAisDataStateComponent>
   {
   public:
       DtAisDataStateComponentImplementation(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()
      {
         if (myNextFrameState.isWritable())
         {
            myCurrentFrameState.advanceFrame(myNextFrameState.frameState());
         }

         myCurrentFrameState.emitComponentUpdated();
      }

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

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

   protected:
       DtAisDataStateComponentCurrentFrame myCurrentFrameState;
       DtAisDataStateComponentNextFrame myNextFrameState;
   };

   typedef DtStateComponentCreator<DtAisDataStateComponentImplementation> DtAisDataStateComponentCreator;
}