modelSetEntry.h

Go to the documentation of this file.

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

#pragma once

#include <vlutil/vlString.h>
#include <readerWriter/readerWriter.h>
#include <readerWriter/rwObjectType.h>
#include <readerWriter/rwBoolean.h>
#include <readerWriter/rwString.h>
#include "vrfutil/rwForces.h"
#include <readerWriter/rwStringAttributeList.h>
#include <readerWriter/rwStringAttribute.h>
#include "vrfutil/rwNLengthStringVector.h"
#include "vrfobjparam/vrfobjparamDefines.h"
#include "mtl/envValue.h"
#include "vrfXmlTypes.h"


class DtModelSetEntry;
typedef DtModelSetEntry* (*DtModelSetEntryCreatorFcn)(const DtString&, DtReaderWriterRegistry* parentRegistry);

class DT_DLL_vrfobjparam DtModelSetEntry : public DtReaderWriter
{
public:
   DtModelSetEntry();

   DtModelSetEntry(const DtString& name, DtReaderWriterRegistry* const parentRegistry = nullptr);

   DtModelSetEntry(const DtModelSetEntry& orig, DtReaderWriterRegistry* const parentRegistry = nullptr);

   virtual DtModelSetEntry& operator=(const DtModelSetEntry & orig);

   virtual ~DtModelSetEntry();

   virtual DtModelSetEntry* clone();

   virtual const char* readerWriterType();

   static DtModelSetEntryCreatorFcn SetModelSetEntryCreatorFcn(DtModelSetEntryCreatorFcn);
   static DtModelSetEntryCreatorFcn ModelSetEntryCreatorFcn();
   static DtModelSetEntry* Create(const DtString& name = "model-set-entry",  DtReaderWriterRegistry* const parentRegistry = nullptr);

   DtString label() const;
   void setLabel(const DtString&);

   DtString platform() const;
   void setPlatform(const DtString&);

   DtString uniqueID() const;
   void setUniqueID(const DtString&);

   void setIsRandomized(bool);
   bool isRandomized() const;

   bool canCreate() const;
   void setCanCreate(bool);

   bool canAggregate() const;
   void setCanAggregate(bool);

   void setObjectType(const DtObjectType&);
   const DtObjectType& objectType() const;

   void setMatchType(const DtObjectType&);
   const DtObjectType& matchType() const;

   const std::list<DtObjectType>& additionalMatchTypes() const;
   std::list<DtObjectType>& additionalMatchTypes();

   DtString menuIcon() const;
   void setMenuIcon(const DtString&);

   void setKeywords(const DtString&);
   DtString keywords() const;

   void setShortName(const DtString&);
   const DtString& shortName() const;

   void setIncludeInBVSPCalcs(bool);
   bool includeInBVSPCalcs() const;

   virtual void setDescription(const DtString&);
   virtual const DtString& description() const;

   void setForces(const DtRwForces&);
   const DtRwForces& forces() const;
   DtRwForces& forces();

   void setCategories(const DtRwNLengthStringVector&);
   const DtRwNLengthStringVector& categories() const;
   bool hasCategory(const DtString&) const;

   void setDefaultOverlayLayer(const DtString&);
   DtString defaultOverlayLayer() const;

   void setDeployableCountries(const DtRwNLengthStringVector&);
   const DtRwNLengthStringVector& deployableCountries() const;

   const DtRwStringAttributeList& iconLists() const;
   DtRwStringAttributeList& iconLists();
   void setIconLists(const DtRwStringAttributeList&);
   void setIconForList(const DtString&, const DtString&);
   DtString iconForList(const DtString&) const;

   virtual bool operator==(const DtModelSetEntry&) const;
   virtual bool operator!=(const DtModelSetEntry&) const;

   virtual void readFromEnvironment(DtEnvironmentSP, DtEnvValueSP objectNode, bool keepCurrentData = false);

   virtual void writeToEnvironment(DtEnvironmentSP, DtEnvValueSP objectNode, std::vector<DtString>* = nullptr, DtModelSetEntry* = nullptr) const;

   virtual void updateImageData(char from, char to) const;

protected:
   DtRwBoolean    myCanCreate;
   DtRwBoolean    myCanAggregate;
   DtRwString     myLabel;
   DtRwString     myUniqueID;
   DtRwString     myKeywords;
   DtRwString     myMenuIcon;
   DtRwString     myDefaultOverlayLayer;
   DtRwString     myDescription;

   DtRwObjectType myObjectType;
   DtRwForces     myForces;
   DtRwNLengthStringVector myCategories;
   DtRwNLengthStringVector myDeployableCountries;
   DtRwStringAttributeList myIconLists;
   DtRwBoolean    myIncludeInBVSPCalcs;
   DtString myPlatform;
   DtString myShortName;
   DtRwBoolean myIsRandomized;

   std::list<DtObjectType> myAdditionalMatchTypes;
   DtObjectType myMatchType;
   static DtModelSetEntryCreatorFcn theModelSetEntryCreatorFcn;
};

inline const DtRwStringAttributeList& DtModelSetEntry::iconLists() const
{
   return myIconLists;
}

inline DtRwStringAttributeList& DtModelSetEntry::iconLists()
{
   return myIconLists;
}

inline void DtModelSetEntry::setIconLists(const DtRwStringAttributeList& l)
{
   myIconLists = l;
}

inline void DtModelSetEntry::setIconForList(const DtString& icon, const DtString& list)
{
   myIconLists.removeStringAttribute(list);
   DtRwStringAttribute atr(list, list, icon);
   myIconLists.addStringAttribute(atr);
}

inline DtString DtModelSetEntry::iconForList(const DtString& key) const
{
   return myIconLists.value(key);
}

inline void DtModelSetEntry::setLabel(const DtString& s)
{
   myLabel = s;
}

inline DtString DtModelSetEntry::label() const
{
   return myLabel;
}

inline void DtModelSetEntry::setPlatform(const DtString& s)
{
   myPlatform = s;
}

inline DtString DtModelSetEntry::platform() const
{
   return myPlatform;
}

inline void DtModelSetEntry::setMenuIcon(const DtString& s)
{
   myMenuIcon = s;
}

inline DtString DtModelSetEntry::menuIcon() const
{
   return myMenuIcon;
}

inline void DtModelSetEntry::setKeywords(const DtString& s)
{
   myKeywords = s;
}

inline DtString DtModelSetEntry::keywords() const
{
   return myKeywords;
}

inline void DtModelSetEntry::setDefaultOverlayLayer(const DtString& s)
{
   myDefaultOverlayLayer = s;
}

inline DtString DtModelSetEntry::defaultOverlayLayer() const
{
   return myDefaultOverlayLayer;
}

inline void DtModelSetEntry::setUniqueID(const DtString& s)
{
   myUniqueID = s;
}

inline DtString DtModelSetEntry::uniqueID() const
{
   return myUniqueID;
}

inline void DtModelSetEntry::setCanCreate(bool b)
{
   myCanCreate = b;
}

inline bool DtModelSetEntry::canCreate() const
{
   return myCanCreate;
}

inline void DtModelSetEntry::setCanAggregate(bool b)
{
   myCanAggregate = b;
}

inline bool DtModelSetEntry::canAggregate() const
{
   return myCanAggregate;
}

inline void DtModelSetEntry::setObjectType(const DtObjectType& o)
{
   myObjectType = o;
}

inline const DtObjectType& DtModelSetEntry::objectType() const
{
   return myObjectType;
}

inline const std::list<DtObjectType>& DtModelSetEntry::additionalMatchTypes() const
{
   return myAdditionalMatchTypes;
}

inline std::list<DtObjectType>& DtModelSetEntry::additionalMatchTypes()
{
   return myAdditionalMatchTypes;
}

inline void DtModelSetEntry::setMatchType(const DtObjectType& o)
{
   myMatchType = o;
}

inline const DtObjectType& DtModelSetEntry::matchType() const
{
   return myMatchType;
}

inline void DtModelSetEntry::setForces(const DtRwForces& f)
{
   myForces = f;
}

inline const DtRwForces& DtModelSetEntry::forces() const
{
   return myForces;
}

inline DtRwForces& DtModelSetEntry::forces()
{
   return myForces;
}

inline void DtModelSetEntry::setCategories(const DtRwNLengthStringVector& c)
{
   myCategories = c;
}

inline const DtRwNLengthStringVector& DtModelSetEntry::categories() const
{
   return myCategories;
}

inline void DtModelSetEntry::setDeployableCountries(const DtRwNLengthStringVector& c)
{
   myDeployableCountries = c;
}

inline const DtRwNLengthStringVector& DtModelSetEntry::deployableCountries() const
{
   return myDeployableCountries;
}

inline void DtModelSetEntry::setIncludeInBVSPCalcs(bool b)
{
   myIncludeInBVSPCalcs = b;
}

inline bool DtModelSetEntry::includeInBVSPCalcs() const
{
   return myIncludeInBVSPCalcs;
}

inline void DtModelSetEntry::setIsRandomized(bool b)
{
   myIsRandomized = b;
}

inline bool DtModelSetEntry::isRandomized() const
{
   return myIsRandomized;
}

inline bool DtModelSetEntry::hasCategory(const DtString& cat) const
{
   return (myCategories.indexOfValue(cat) != -1);
}