assembliesReaderWriter.h

Go to the documentation of this file.

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


#pragma once

#if !defined(Q_MOC_RUN)
#include "vrfutil/vrfutilDefines.h"
#include <readerWriter/readerWriter.h>
#include "vrfutil/rwTemplatedList.h"
#include <mtl/envObject.h>
#endif

#include <string>
#include <map>

class DtFilename;

class DT_DLL_vrfutil DtAssembliesReaderWriter : public DtReaderWriter
{
public:
   class RwValue;

   class RootNodeContainer;

   class DT_DLL_vrfutil RwRootNode : public DtReaderWriter
   {
   public:
      RwRootNode(const DtString& rwName = "rootNode", DtReaderWriterRegistry* parentRegistry = 0);

      RwRootNode(const RwRootNode& name, DtReaderWriterRegistry* parentRegistry = 0);

      virtual ~RwRootNode() override;

      bool operator==(const RwRootNode& rhs) const;

      virtual const char* readerWriterType() const override;

      static const char* theXmlType();

      virtual const char* xmlType() const override
      {
         return theXmlType();
      }

      RwRootNode& operator=(const RwRootNode&);

      virtual void clear();

      virtual RwRootNode* find(const DtString& keyword) const;

      virtual bool collectAllItemsOfType(const std::string&, RwRootNode&) const;

      virtual RwRootNode* findByRwName(const DtString& name) const;

      virtual std::map<DtString, RwRootNode*> keywordMap() const;

      virtual std::map<DtString, RwRootNode*> displayNameMap() const;

      virtual void setAttributes(const std::map<std::string, std::string>&);
      virtual std::map<std::string, std::string> attributesMap() const;

      virtual RwRootNode* findByNameAndKeyword(const DtString& rwName, const DtString& keyword) const;

      virtual DtString findAttributeValue(const std::string& keyword) const;
      virtual void addAttribute(const DtString& kw, const DtString& val);
      virtual void removeAttribute(const DtString& kw);
      virtual void getSelf(const DtEnvironmentSP env, const DtEnvValueSP root,
         const DtReaderWriter::SearchPaths& searchPaths, const DtVariableBindingsList& varBindings) override;
      virtual void getSelf(DtlObjPtr args, const DtReaderWriter::SearchPaths& searchPaths,
            const DtVariableBindingsList& variableBindings) override
      {
         DtReaderWriter::getSelf(args, searchPaths, variableBindings);
      }

      int count() const
      {
         return myRegistry.registryData().size();
      }

      void setIncluded(bool b) { myIncluded = b; };
      bool included() const { return myIncluded; };

      DtRwString              myDisplayName;
      DtRwString              myKeyword;
      DtRwTemplatedStringList myAttributes;

      RootNodeContainer*    myChildren;
      bool myIncluded = false;
   };

   class DT_DLL_vrfutil RootNodeContainer : public DtRwTemplatedListPtr<RwRootNode, true>
   {
   public:
      RootNodeContainer(const DtString& = "rootNodeContainer", DtReaderWriterRegistry* parent = 0);
      RootNodeContainer(const RootNodeContainer&, DtReaderWriterRegistry* parent = 0);
      virtual ~RootNodeContainer() override;

      bool operator==(const RootNodeContainer& orig) const
      {
         return (*(static_cast<const DtRwTemplatedListPtr<RwRootNode, true>*>(this)) == orig);
      }

      RootNodeContainer& operator=(const RootNodeContainer& rhs)
      {
         if (this != &rhs)
         {
            (*(static_cast<DtRwTemplatedListPtr<RwRootNode, true>*>(this)) = rhs);
         }

         return *this;
      }

      virtual std::map<DtString, RwRootNode*> keywordMap() const;

      virtual std::map<DtString, RwRootNode*> displayNameMap() const;

      virtual RwRootNode* find(const DtString& keyword) const;

      virtual RwRootNode* findByRwName(const DtString& name) const;

      virtual RwRootNode* findByNameAndKeyword(const DtString& rwName, const DtString& keyword) const;
   };

   DtAssembliesReaderWriter(const DtString& rwName = "assemblies", DtReaderWriterRegistry* parentRegistry = 0);

   DtAssembliesReaderWriter(const DtAssembliesReaderWriter& name, DtReaderWriterRegistry* parentRegistry = 0);

   const DtAssembliesReaderWriter& operator=(const DtAssembliesReaderWriter & orig);

   virtual ~DtAssembliesReaderWriter() override;

   virtual bool load(const DtFilename&);

   virtual bool save(const DtFilename&);

   virtual DtString displayNameForKeyword(const DtString&,
      DtString* module = 0) const;

   virtual void setAssembliesRootNodes(const RootNodeContainer& a);
   virtual const RootNodeContainer& assembliesRootNodes() const;
   virtual RootNodeContainer& assembliesRootNodes();

   virtual void setAmmunitionRootNodes(const RootNodeContainer& a);
   virtual const RootNodeContainer& ammunitionRootNodes() const;
   virtual RootNodeContainer& ammunitionRootNodes();

   virtual void setWeaponRootNodes(const RootNodeContainer& a);
   virtual const RootNodeContainer& weaponRootNodes() const;
   virtual RootNodeContainer& weaponRootNodes();

   virtual void setEquipmentRootNodes(const RootNodeContainer& a);
   virtual const RootNodeContainer& equipmentRootNodes() const;
   virtual RootNodeContainer& equipmentRootNodes();

   virtual void setVariableRootNodes(const RootNodeContainer& a);
   virtual const RootNodeContainer& variableRootNodes() const;
   virtual RootNodeContainer& variableRootNodes();

   virtual const char* readerWriterType() const override;

   static const char* theXmlType();

   virtual const char* xmlType() const override
   {
      return theXmlType();
   }

   virtual void clear();

   virtual std::map<std::string, std::string> ammunition() const;

   virtual std::map<std::string, std::string> equipment() const;

   virtual std::map<std::string, std::string> variables() const;

   virtual std::map<std::string, std::string> weapons() const;

   virtual std::map<std::string, std::string> assemblies() const;

   virtual RwRootNode* rootNodeFor(const DtString&) const;

   virtual const RwRootNode& rollUpRules() const;
   virtual RwRootNode& rollUpRules();
   virtual void addRollUpRule(const std::string& rule, const std::string& element,
      const std::map<std::string, std::string>& attributes = std::map<std::string, std::string>());
   virtual bool rollUpRuleFor(const DtString& variable, DtString& rule, std::map<std::string, std::string>& attributes) const;
   virtual void setRollUpRules(const RwRootNode&);

protected:

   virtual std::map<std::string, std::string> convertToMap(const RootNodeContainer&) const;

protected:
   RootNodeContainer myAmmunitionRootNodes;
   RootNodeContainer myEquipmentRootNodes;
   RootNodeContainer myVariableRootNodes;
   RootNodeContainer myWeaponRootNodes;
   RootNodeContainer myAssemblyRootNodes;
   RwRootNode        myRollUpRules;
};