emitterSystemStateComponent.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 <tbb/spin_mutex.h>
#include <queue>
#include <vrfutil/rwUUID.h>
#include <matrix/vlVector.h>
#include <set>

namespace makVrf
{
   struct DtEmitterSystemBeamStateData;
   class DtEmitterSystemStateComponent;

   typedef bool(*DtVerifyTrackJamTargetCallback)(const DtUUID& target, const DtEmitterSystemBeamStateData& beam, void * usr);

   struct DT_DLL_vrfStateData DtEmitterSystemBeamStateData
   {
      enum BeamType
      {
         RegularBeam = -1,
         RadarBeam = 1,
         TrackBeam = 1,
         JamBeam = 0
      };

      DtEmitterSystemBeamStateData()
      : mySystemId(0)
      , myBeamId(0)
      , myBeamType(-1)
      , myJammingModeSequence(0)
      , myFrequency(0.)
      , myFrequencyRange(0.)
      , myERP(0.)
      , myAzimuthCenter(0.)
      , myAzimuthSweep(0.)
      , myElevationCenter(0.)
      , myElevationSweep(0.)
      , myPRF(0.)
      , myPulseWidth(0.)
      , mySweepSync(0.)
      , myBeamParameterIndex(0)
      , myBeamFunction(0)
      , myHighDensity(false)
      {
      }

      DtEmitterSystemBeamStateData(const DtEmitterSystemBeamStateData& orig)
      : mySystemId(orig.mySystemId)
      , myBeamId(orig.myBeamId)
      , myBeamType(orig.myBeamType)
      , myJammingModeSequence(orig.myJammingModeSequence)
      , myFrequency(orig.myFrequency)
      , myFrequencyRange(orig.myFrequencyRange)
      , myERP(orig.myERP)
      , myAzimuthCenter(orig.myAzimuthCenter)
      , myAzimuthSweep(orig.myAzimuthSweep)
      , myElevationCenter(orig.myElevationCenter)
      , myElevationSweep(orig.myElevationSweep)
      , myPRF(orig.myPRF)
      , myPulseWidth(orig.myPulseWidth)
      , mySweepSync(orig.mySweepSync)
      , myBeamParameterIndex(orig.myBeamParameterIndex)
      , myBeamFunction(orig.myBeamFunction)
      , myHighDensity(orig.myHighDensity)
      , myTrackJamTargets(orig.myTrackJamTargets)
      {
      }

      DtEmitterSystemBeamStateData& operator=(const DtEmitterSystemBeamStateData& rhs)
      {
         mySystemId = rhs.mySystemId;
         myBeamId = rhs.myBeamId;
         myBeamType = rhs.myBeamType;
         myJammingModeSequence = rhs.myJammingModeSequence;
         myFrequency = rhs.myFrequency;
         myFrequencyRange = rhs.myFrequencyRange;
         myERP = rhs.myERP;
         myAzimuthCenter = rhs.myAzimuthCenter;
         myAzimuthSweep = rhs.myAzimuthSweep;
         myElevationCenter = rhs.myElevationCenter;
         myElevationSweep = rhs.myElevationSweep;
         myPRF = rhs.myPRF;
         myPulseWidth = rhs.myPulseWidth;
         mySweepSync = rhs.mySweepSync;
         myBeamParameterIndex = rhs.myBeamParameterIndex;
         myBeamFunction = rhs.myBeamFunction;
         myHighDensity = rhs.myHighDensity;
         myTrackJamTargets = rhs.myTrackJamTargets;

         return *this;
      }

      bool operator==(const DtEmitterSystemBeamStateData& rhs) const
      {
         return ((mySystemId == rhs.mySystemId) &&
                 (myBeamId == rhs.myBeamId) &&
                 (myBeamType == rhs.myBeamType) &&
                 (myJammingModeSequence == rhs.myJammingModeSequence) &&
                 (myFrequency == rhs.myFrequency) &&
                 (myFrequencyRange == rhs.myFrequencyRange) &&
                 (myERP == rhs.myERP) &&
                 (myAzimuthCenter == rhs.myAzimuthCenter) &&
                 (myAzimuthSweep == rhs.myAzimuthSweep) &&
                 (myElevationCenter == rhs.myElevationCenter) &&
                 (myElevationSweep == rhs.myElevationSweep) &&
                 (myPRF == rhs.myPRF) &&
                 (myPulseWidth == rhs.myPulseWidth) &&
                 (mySweepSync == rhs.mySweepSync) &&
                 (myBeamParameterIndex == rhs.myBeamParameterIndex) &&
                 (myBeamFunction == rhs.myBeamFunction) &&
                 (myHighDensity == rhs.myHighDensity) &&
                 (myTrackJamTargets == rhs.myTrackJamTargets));
      }

      bool operator!=(const DtEmitterSystemBeamStateData& rhs) const { return !(*this == rhs); };

      DEFINE_ACCESSOR_MUTATOR(unsigned short, beamId, BeamId)
      DEFINE_ACCESSOR_MUTATOR(unsigned int, systemId, SystemId)
      DEFINE_ACCESSOR_MUTATOR(int, beamType, BeamType)
      DEFINE_ACCESSOR_MUTATOR(unsigned int, jammingModeSequence, JammingModeSequence)
      DEFINE_ACCESSOR_MUTATOR(double, frequency, Frequency)
      DEFINE_ACCESSOR_MUTATOR(double, frequencyRange, FrequencyRange)
      DEFINE_ACCESSOR_MUTATOR(double, ERP, ERP)
      DEFINE_ACCESSOR_MUTATOR(double, azimuthCenter, AzimuthCenter)
      DEFINE_ACCESSOR_MUTATOR(double, azimuthSweep, AzimuthSweep)
      DEFINE_ACCESSOR_MUTATOR(double, elevationCenter, ElevationCenter)
      DEFINE_ACCESSOR_MUTATOR(double, elevationSweep, ElevationSweep)
      DEFINE_ACCESSOR_MUTATOR(double, PRF, PRF)
      DEFINE_ACCESSOR_MUTATOR(double, pulseWidth, PulseWidth)
      DEFINE_ACCESSOR_MUTATOR(double, sweepSync, SweepSync)
      DEFINE_ACCESSOR_MUTATOR(unsigned int, beamParameterIndex, BeamParameterIndex)
      DEFINE_ACCESSOR_MUTATOR(unsigned int, beamFunction, BeamFunction)
      DEFINE_ACCESSOR_MUTATOR(bool, highDensity, HighDensity)

      void addTrackJamTarget(const DtUUID& s) { myTrackJamTargets.insert(s); };
      void removeTrackJamTarget(const DtUUID& s) { myTrackJamTargets.erase(s); };
      const std::set<DtUUID>& trackJamTargets() const { return myTrackJamTargets; };
      bool hasTrackJamTarget(const DtUUID&  s) const { return (myTrackJamTargets.find(s) != myTrackJamTargets.end()); };
      void clearTrackJamTargets() { myTrackJamTargets.clear(); };
      void setTrackJamTargets(const std::set<DtUUID>& t) { myTrackJamTargets = t; };

   protected:
      unsigned short myBeamId;
      unsigned int mySystemId;
      int myBeamType;
      unsigned int myJammingModeSequence;
      double myFrequency;
      double myFrequencyRange;
      double myERP;
      double myAzimuthCenter;
      double myAzimuthSweep;
      double myElevationCenter;
      double myElevationSweep;
      double myPRF;
      double myPulseWidth;
      double mySweepSync;
      unsigned int myBeamParameterIndex;
      unsigned int myBeamFunction;
      bool myHighDensity;
      std::set<DtUUID> myTrackJamTargets;
   };

   struct DT_DLL_vrfStateData DtEmitterSystemStateComponentData
   {
      struct DtEmitterSystemBeams
      {
      public:
         DtEmitterSystemBeams()
         : nextId(0)
         {};

         DtEmitterSystemBeams(const DtEmitterSystemBeams& orig)
         : beams(orig.beams)
         {
         };

         DtEmitterSystemBeams& operator=(const DtEmitterSystemBeams& rhs)
         {
            beams = rhs.beams;

            return *this;
         }

         int size() const
         {
            return beams.size();
         }

         DtEmitterSystemBeamStateData* operator[](unsigned short beamId)
         {
            std::vector<DtEmitterSystemBeamStateData>::iterator iter = beams.begin();
            std::vector<DtEmitterSystemBeamStateData>::iterator end = beams.end();
            while (iter != end)
            {
               if (iter->beamId() == beamId)
               {
                  return &(*iter);
               }

               ++iter;
            }

            return 0;
         }

         const DtEmitterSystemBeamStateData* operator[](unsigned short beamId) const
         {
            std::vector<DtEmitterSystemBeamStateData>::const_iterator iter = beams.begin();
            std::vector<DtEmitterSystemBeamStateData>::const_iterator end = beams.end();
            while (iter != end)
            {
               if (iter->beamId() == beamId)
               {
                  return &(*iter);
               }

               ++iter;
            }

            return 0;
         }

         void removeBeam(unsigned int beamIndex)
         {
            std::vector<DtEmitterSystemBeamStateData>::iterator iter = beams.begin();
            std::vector<DtEmitterSystemBeamStateData>::iterator end = beams.end();
            while (iter != end)
            {
               if (iter->beamId() == beamIndex)
               {
                  beams.erase(iter);
                  break;
               }

               ++iter;
            }
         }

         bool tracking(DtEmitterSystemBeamStateData::BeamType type, const DtUUID& gid) const
         {
            return (beamsTrackingObject(type, gid).size() != 0);
         }

         std::vector<const DtEmitterSystemBeamStateData*> beamsTrackingObject(DtEmitterSystemBeamStateData::BeamType type, const DtUUID& gid) const
         {
            std::vector<DtEmitterSystemBeamStateData>::const_iterator iter = beams.begin();
            std::vector<DtEmitterSystemBeamStateData>::const_iterator end = beams.end();
            std::vector<const DtEmitterSystemBeamStateData*> lst;

            while (iter != beams.end())
            {
               if ((iter->beamType() == type) && iter->hasTrackJamTarget(gid))
               {
                  lst.push_back(&(*iter));
               }

               ++iter;
            }

            return lst;
         }

         DtEmitterSystemBeamStateData* addBeam()
         {
            unsigned short id = nextBeamId();

            DtEmitterSystemBeamStateData data;
            data.setBeamId(id);

            beams.push_back(data);

            return &beams[beams.size() - 1];
         }

         unsigned short nextBeamId() const
         {
            return ++nextId;
         }

         DtEmitterSystemBeamStateData* beamByBeamId(unsigned short beamId)
         {
            return (*this)[beamId];
         }

         const DtEmitterSystemBeamStateData* beamByBeamId(unsigned short beamId) const
         {
            return (*this)[beamId];
         }

         DtEmitterSystemBeamStateData* beamByBeamIndex(unsigned short index)
         {
            if (index < beams.size())
            {
               return &beams[index];
            }

            return 0;
         }

         const DtEmitterSystemBeamStateData* beamByBeamIndex(unsigned short index) const
         {
            if (index < beams.size())
            {
               return &beams[index];
            }

            return 0;
         }

         void removeAllBeams()
         {
            nextId = 0;
            beams.clear();
         }

         std::vector<DtEmitterSystemBeamStateData> beams;
         mutable unsigned short nextId;
      };

      DtEmitterSystemStateComponentData()
      : myOn(true)
      , mySystemName(0)
      , myEmitterFunction(0)
      , mySystemId(0)
      {
      }

      DtEmitterSystemStateComponentData(const DtEmitterSystemStateComponentData& orig)
      : myOn(orig.myOn)
      , mySystemName(orig.mySystemName)
      , myEmitterFunction(orig.myEmitterFunction)
      , myMountLocation(orig.myMountLocation)
      , myBeamsList(orig.myBeamsList)
      , mySystemId(orig.mySystemId)
      , myGlobalId(orig.myGlobalId)
      {
      }

      DtEmitterSystemStateComponentData& operator=(const DtEmitterSystemStateComponentData& rhs)
      {
         myOn = rhs.myOn;
         mySystemName = rhs.mySystemName;
         myEmitterFunction = rhs.myEmitterFunction;
         myMountLocation = rhs.myMountLocation;
         myBeamsList = rhs.myBeamsList;
         mySystemId = rhs.mySystemId;
         myGlobalId = rhs.myGlobalId;

         return *this;
      }

      DtEmitterSystemBeamStateData* beamByBeamId(unsigned short beamId)
      {
         return myBeamsList.beamByBeamId(beamId);
      }

      const DtEmitterSystemBeamStateData* beamByBeamId(unsigned short beamId) const
      {
         return myBeamsList.beamByBeamId(beamId);
      }

      DtEmitterSystemBeamStateData* beamByBeamIndex(unsigned short beamId)
      {
         return myBeamsList.beamByBeamIndex(beamId);
      }

      const DtEmitterSystemBeamStateData* beamByBeamIndex(unsigned short beamId) const
      {
         return myBeamsList.beamByBeamIndex(beamId);
      }

      unsigned int numBeams() const { return myBeamsList.size(); };
      DtEmitterSystemBeamStateData* addBeam() { return myBeamsList.addBeam(); };
      DtEmitterSystemBeams& beams() { return myBeamsList; };
      const DtEmitterSystemBeams& beams() const { return myBeamsList; };
      const std::vector<DtEmitterSystemBeamStateData>& rawBeams() const { return myBeamsList.beams; };
      std::vector<DtEmitterSystemBeamStateData>& rawBeams() { return myBeamsList.beams; };

      bool tracking(const DtUUID& gid) const
      {
         return myBeamsList.tracking(DtEmitterSystemBeamStateData::TrackBeam, gid);
      }

      bool tracking(const DtUUID& gid)
      {
         return myBeamsList.tracking(DtEmitterSystemBeamStateData::TrackBeam, gid);
      }

      std::vector<const DtEmitterSystemBeamStateData*> beamsTrackingObject(DtEmitterSystemBeamStateData::BeamType type, const DtUUID& gid) const
      {
         return myBeamsList.beamsTrackingObject(type, gid);
      }

      std::vector<const DtEmitterSystemBeamStateData*> beamsTrackingObject(const DtUUID& gid) const
      {
         return myBeamsList.beamsTrackingObject(DtEmitterSystemBeamStateData::TrackBeam, gid);
      }

      std::vector<const DtEmitterSystemBeamStateData*> beamsJammingObject(const DtUUID& gid) const
      {
         return myBeamsList.beamsTrackingObject(DtEmitterSystemBeamStateData::JamBeam, gid);
      }

      bool jamming(const DtUUID& gid) const
      {
         return myBeamsList.tracking(DtEmitterSystemBeamStateData::JamBeam, gid);
      }

      bool jamming(const DtUUID& gid)
      {
         return myBeamsList.tracking(DtEmitterSystemBeamStateData::JamBeam, gid);
      }

      void removeAllBeams() { myBeamsList.removeAllBeams(); };
      void removeBeam(unsigned short beamId) { myBeamsList.removeBeam(beamId); };

      DEFINE_ACCESSOR_MUTATOR(DtString, globalId, GlobalId)
      DEFINE_ACCESSOR_MUTATOR(bool, on, On)
      DEFINE_ACCESSOR_MUTATOR(unsigned int, systemId, SystemId)
      DEFINE_ACCESSOR_MUTATOR(unsigned int, systemName, SystemName)
      DEFINE_ACCESSOR_MUTATOR(unsigned int, emitterFunction, EmitterFunction)
      DEFINE_ACCESSOR_MUTATOR(DtVector, mountLocation, MountLocation)

   protected:
      DtString myGlobalId; 
      bool myOn;
      unsigned int mySystemId;
      unsigned int mySystemName;
      unsigned int myEmitterFunction;
      DtVector myMountLocation;
      DtEmitterSystemBeams myBeamsList;
   };

   class DT_DLL_vrfStateData DtEmitterSystemStateComponent : public DtFrameStateInterface
   {
   public:
      DEFINE_STATE_COMPONENT_TYPE(DtStateComponent::EmitterSystemStateComponent)

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

      UNDEFINED_RETURNVALUE_ACCESSOR(DtUUID, hostId)
      UNDEFINED_RETURNREF_ACCESSOR_MUTATOR(DtString, globalId, GlobalId)
      UNDEFINED_RETURNREF_ACCESSOR_MUTATOR(unsigned int, systemName, SystemName)
      UNDEFINED_RETURNREF_ACCESSOR_MUTATOR(unsigned int, emitterFunction, EmitterFunction)
      UNDEFINED_RETURNREF_ACCESSOR_MUTATOR(bool, on, On)
      UNDEFINED_RETURNREF_ACCESSOR_MUTATOR(DtVector, mountLocation, MountLocation)
      UNDEFINED_METHOD(void, removeAllBeams)
      UNDEFINED_METHOD(void, removeBeam, unsigned short beamId)
      UNDEFINED_RETURNVALUE_ACCESSOR(unsigned int, numBeams)
      UNDEFINED_METHOD(DtEmitterSystemBeamStateData*, addBeam)
      virtual const DtEmitterSystemBeamStateData* beamByBeamIndex(unsigned short beamIndex) const { throw DtUnimplementedMethod("The const beamByBeamIndex() const method is unimplemented"); };
      virtual const DtEmitterSystemBeamStateData* beamByBeamId(unsigned short beamId) const { throw DtUnimplementedMethod("The const beamByBeamId() const method is unimplemented"); };
      virtual DtEmitterSystemBeamStateData* beamByBeamIndex(unsigned short beamIndex) { throw DtUnimplementedMethod("The beamByBeamIndex() method is unimplemented"); };
      virtual DtEmitterSystemBeamStateData* beamByBeamId(unsigned short beamId) { throw DtUnimplementedMethod("The beamByBeamId() method is unimplemented"); };
      UNDEFINED_RETURNREF_ACCESSORS(std::vector<DtEmitterSystemBeamStateData>, beams)
      virtual const std::vector<const DtEmitterSystemBeamStateData*> beamsTrackingObject(DtEmitterSystemBeamStateData::BeamType type, const DtUUID& gid) const { throw DtUnimplementedMethod("The const beamsTrackingObject() const method is unimplemented"); };
      virtual const std::vector<const DtEmitterSystemBeamStateData*> beamsTrackingObject(const DtUUID& gid) const { throw DtUnimplementedMethod("The const beamsTrackingObject() const method is unimplemented"); };
      virtual const std::vector<const DtEmitterSystemBeamStateData*> beamsJammingObject(const DtUUID& gid) const { throw DtUnimplementedMethod("The const beamsJammingObject() const method is unimplemented"); };
      virtual void addTrackJamTarget(const DtUUID& globalId, DtEmitterSystemBeamStateData::BeamType,
         DtVerifyTrackJamTargetCallback = 0, void* userData = 0) { throw DtUnimplementedMethod("The addTrackJamTarget(const DtUUID& globalId, DtEmitterSystemBeamStateData::BeamType) const method is unimplemented"); };
      virtual void removeTrackJamTarget(const DtUUID& globalId, DtEmitterSystemBeamStateData::BeamType) { throw DtUnimplementedMethod("The removeTrackJamTarget(const DtUUID& globalId, DtEmitterSystemBeamStateData::BeamType) const method is unimplemented"); };

      UNDEFINED_CONST_METHOD(bool, tracking, const DtUUID& gid)
      UNDEFINED_CONST_METHOD(bool, jamming, const DtUUID& gid)
   };

   class DT_DLL_vrfStateData DtEmitterSystemStateComponentNextFrame : public DtEmitterSystemStateComponent
   {
   public:
      DtEmitterSystemStateComponentNextFrame(DtStateData* storage);

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

      const std::vector<DtEmitterSystemBeamStateData>& beams() const;
      std::vector<DtEmitterSystemBeamStateData>& beams();

      const DtUUID hostId() const;

      const DtString& globalId() const;
      void setGlobalId(const DtString&);

      const unsigned int& systemName() const;
      void setSystemName(const unsigned int&);

      const unsigned int& emitterFunction() const;
      void setEmitterFunction(const unsigned int&);

      const bool& on() const;
      void setOn(const bool&);

      const DtVector& mountLocation() const;
      void setMountLocation(const DtVector&);

      const unsigned int numBeams() const;

      const DtEmitterSystemBeamStateData* beamByBeamIndex(unsigned short beamIndex) const;
      DtEmitterSystemBeamStateData* beamByBeamIndex(unsigned short beamIndex);

      const DtEmitterSystemBeamStateData* beamByBeamId(unsigned short beamId) const;
      DtEmitterSystemBeamStateData* beamByBeamId(unsigned short beamId);

      void removeAllBeams();
      void removeBeam(unsigned short beamId);
      DtEmitterSystemBeamStateData* addBeam();

      const std::vector<const DtEmitterSystemBeamStateData*> beamsTrackingObject(DtEmitterSystemBeamStateData::BeamType type, const DtUUID& gid) const;
      const std::vector<const DtEmitterSystemBeamStateData*> beamsTrackingObject(const DtUUID& gid) const;
      const std::vector<const DtEmitterSystemBeamStateData*> beamsJammingObject(const DtUUID& gid) const;

      bool tracking(const DtUUID& gid) const;
      bool jamming(const DtUUID& gid) const;

      void addTrackJamTarget(const DtUUID& globalId, DtEmitterSystemBeamStateData::BeamType, DtVerifyTrackJamTargetCallback = 0, void* userData = 0);
      void removeTrackJamTarget(const DtUUID& globalId, DtEmitterSystemBeamStateData::BeamType);

      virtual void makeWritable() {};

      virtual void makeReadOnly() {};

   protected:
      unsigned short myNextBeamId;
      DtStateData* myStateData;
      DtEmitterSystemStateComponentData myData;
   };

   class DT_DLL_vrfStateData DtEmitterSystemStateComponentCurrentFrame : public DtEmitterSystemStateComponent
   {
   public:
      DtEmitterSystemStateComponentCurrentFrame(DtStateData* storage);

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

      const std::vector<DtEmitterSystemBeamStateData>& beams() const;
      const DtUUID hostId() const;
      const DtString& globalId() const;
      const unsigned int& systemName() const;
      const unsigned int& emitterFunction() const;
      const bool& on() const;
      const DtVector& mountLocation() const;
      const unsigned int numBeams() const;
      const DtEmitterSystemBeamStateData* beamByBeamIndex(unsigned short beamIndex) const;
      const DtEmitterSystemBeamStateData* beamByBeamId(unsigned short beamId) const;
      bool tracking(const DtUUID& gid) const;
      bool jamming(const DtUUID& gid) const;
      const std::vector<const DtEmitterSystemBeamStateData*> beamsTrackingObject(DtEmitterSystemBeamStateData::BeamType type, const DtUUID& gid) const;
      const std::vector<const DtEmitterSystemBeamStateData*> beamsTrackingObject(const DtUUID& gid) const;
      const std::vector<const DtEmitterSystemBeamStateData*> beamsJammingObject(const DtUUID& gid) const;

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

   protected:
      DtStateData* myStateData;
      DtEmitterSystemStateComponentData myData;
   };

   class DT_DLL_vrfStateData DtEmitterSystemStateComponentImplementation : public DtDoubleBufferedStateComponent<DtEmitterSystemStateComponent>
   {
   public:
      DtEmitterSystemStateComponentImplementation(DtStateData* sd);

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

      virtual bool forceAdvance();

      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<DtEmitterSystemStateComponent>::aboutToBeDeleted();
         myCurrentFrameState.aboutToBeDeleted();
         myNextFrameState.aboutToBeDeleted();
      }

   protected:
      DtEmitterSystemStateComponentCurrentFrame myCurrentFrameState;
      DtEmitterSystemStateComponentNextFrame myNextFrameState;
   };

   typedef DtStateComponentCreator<DtEmitterSystemStateComponentImplementation> DtEmitterSystemStateComponentCreator;
}