entityCreationData.h

Go to the documentation of this file.

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



#pragma once

#include <vrfGuiCore/vrfGuiCore.h>

#include <matrix/vlVector.h>
#include <vlpi/entityType.h>
#include <vlpi/appearance.h>
#include <vlutil/vlString.h>
#include <vrfutil/predefinedEntityTypes.h>
#include <vrfutil/rwIntegerAttributeList.h>
#include <vrfutil/rwUUID.h>

#include <map>

namespace makVrf
{
   class DT_DLL_VRFGUICORE DtEntityCreationData
   {
   public:
      DtEntityCreationData(const DtEntityType& entType, int force, const DtVector& location,
         const std::string& name = "", const std::string& label = "", double heading = 0.,
         const DtAppearance& appearance = DtAppearance::nullAppearance(), bool clampToGround = true,
         bool createSubordinates = true, int requestId = -1, const std::string& initialFormation = "",
         int aggregateState = 0, const std::map<std::string, std::string>& extendedData = std::map<std::string, std::string>(),
         const std::map<int, DtString>& extendedLabels = std::map<int, DtString>(), const std::string& overlayParent = "",
         const DtString& globalId = "")
      : myName(name)
      , myLabel(label)
      , myEntityType(entType)
      , myForce(force)
      , myLocation(location)
      , myHeading(heading)
      , myPitch(0.)
      , myAppearance(appearance)
      , myClamp(clampToGround)
      , myCreateSubordinates(createSubordinates)
      , myRequestId(requestId)
      , myInitialFormation(initialFormation)
      , myAggregateState(aggregateState)
      , myExtendedData(extendedData)
      , myExtendedLabels(extendedLabels)
      , myOverlayParent(overlayParent)
      , myUUID(DtUUID::nullUUID())
      , myUsingMagneticNorth(false)
      , myGlobalId(globalId)
      {
      }

      DtEntityCreationData(const DtEntityCreationData& orig)
      : myName(orig.myName)
      , myLabel(orig.myLabel)
      , myEntityType(orig.myEntityType)
      , myForce(orig.myForce)
      , myLocation(orig.myLocation)
      , myHeading(orig.myHeading)
      , myPitch(orig.myPitch)
      , myAppearance(orig.myAppearance)
      , myClamp(orig.myClamp)
      , myCreateSubordinates(orig.myCreateSubordinates)
      , myRequestId(orig.myRequestId)
      , myInitialFormation(orig.myInitialFormation)
      , myAggregateState(orig.myAggregateState)
      , myExtendedData(orig.myExtendedData)
      , myExtendedLabels(orig.myExtendedLabels)
      , myOverlayParent(orig.myOverlayParent)
      , myUUID(orig.myUUID)
      , myUsingMagneticNorth(orig.myUsingMagneticNorth)
      , myGlobalId(orig.myGlobalId)
      {
      }

      void setOverlayParent(const std::string& overlayParent)
      {
         myOverlayParent = overlayParent;
      }

      const std::string& overlayParent() const
      {
         return myOverlayParent;
      }

      void setExtendedLabels(const std::map<int, DtString>& extendedData)
      {
         myExtendedLabels = extendedData;
      }

      const std::map<int, DtString>& extendedLabels() const
      {
         return myExtendedLabels;
      }

      std::map<int, DtString>& extendedLabels()
      {
         return myExtendedLabels;
      }

      void setExtendedData(const std::map<std::string, std::string>& e)
      {
         myExtendedData = e;
      }

      const std::map<std::string, std::string>& extendedData() const
      {
         return myExtendedData;
      }

      std::map<std::string, std::string>& extendedData()
      {
         return myExtendedData;
      }

      void setGlobalId(const DtString& s)
      {
         myGlobalId = s;
      }
      
      const DtString& globalId() const
      {
         return myGlobalId;
      }

      void setName(const std::string& n)
      {
         myName = n;
      }

      const std::string& name() const
      {
         return myName;
      }

      void setLabel(const std::string& l)
      {
         myLabel = l;
      }

      const std::string& label() const
      {
         return myLabel;
      }

      void setEntityType(const DtEntityType& e)
      {
         myEntityType = e;
      }

      const DtEntityType& entityType() const
      {
         return myEntityType;
      }

      void setForce(int f)
      {
         myForce = f;
      }

      int force() const
      {
         return myForce;
      }

      void setLocation(const DtVector& v)
      {
         myLocation = v;
      }

      const DtVector& location() const
      {
         return myLocation;
      }

      void setHeading(double h)
      {
         myHeading = h;
      }

      const bool usingMagneticNorth() const
      {
         return myUsingMagneticNorth;
      }

      void setUsingMagneticNorth(bool b)
      {
         myUsingMagneticNorth = b;
      }

      double heading() const
      {
         return myHeading;
      }

      void setPitch(double h)
      {
         myPitch = h;
      }

      double pitch() const
      {
         return myPitch;
      }

      void setAppearance(const DtAppearance& app)
      {
         myAppearance = app;
      }

      const DtAppearance& appearance() const
      {
         return myAppearance;
      }

      void setClampToGround(bool b)
      {
         myClamp = b;
      }

      bool clampToGround() const
      {
         return myClamp;
      }

      void setCreateSubordinates(bool b)
      {
         myCreateSubordinates = b;
      }

      bool createSubordinates() const
      {
         return myCreateSubordinates;
      }

      void setRequestId(int i)
      {
         myRequestId = i;
      }

      int requestId() const
      {
         return myRequestId;
      }

      void setInitialFormation(const std::string& l)
      {
         myInitialFormation = l;
      }

      const std::string& initialFormation() const
      {
         return myInitialFormation;
      }

      void setAggregateState(int i)
      {
         myAggregateState = i;
      }

      int aggregateState() const
      {
         return myAggregateState;
      }

      void setUUID(const DtUUID& uuid)
      {
         myUUID = uuid;
      }

      const DtUUID& uuid() const
      {
         return myUUID;
      }

   protected:
      DtEntityType   myEntityType;
      int            myForce;
      DtVector       myLocation;
      std::string    myName;
      std::string    myLabel;
      double         myHeading;
      bool           myUsingMagneticNorth;       //is the heading relative to magnetic vs. true north 
      double         myPitch;
      DtAppearance   myAppearance;
      bool           myClamp;
      bool           myCreateSubordinates;
      int            myRequestId;

      std::string    myInitialFormation;
      std::map<std::string, std::string> myExtendedData;
      std::map<int, DtString> myExtendedLabels;
      int            myAggregateState;
      std::string myOverlayParent;

      DtUUID         myUUID;  
      DtString       myGlobalId;
   };
}