rwPropertiesMap.h

Go to the documentation of this file.

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


#pragma once

#include <readerWriter/rwPropertiesList.h>

class DT_DLL_readerWriter DtRwPropertiesMap : public DtRwPropertiesList
{
private:
   DtRwPropertiesMap();

public:

   DtRwPropertiesMap(const DtString& name, DtReaderWriterRegistry* parentRegistry = 0);
   DtRwPropertiesMap(const DtString& name, const DtString& keyType, 
      const DtPropertyInterface* prototype, DtReaderWriterRegistry* parentRegistry = 0);
   DtRwPropertiesMap(const DtString& name, const DtRwPropertiesMap& orig,
      DtReaderWriterRegistry* parentRegistry = 0);
   virtual ~DtRwPropertiesMap() override;
 
   struct Key
   {
      Key(const Key& rhs) : 
         myStr(rhs.myStr), myInt(rhs.myInt), myDbl(rhs.myDbl), myType(rhs.myType) {};

      Key(const DtString& str) : myStr(str), myInt(0), myDbl(0), myType(StrType) {};

      Key(int i) : myStr(), myInt(i), myDbl(0), myType(IntType) {};

      Key(double d) : myStr(), myInt(0), myDbl(d), myType(DoubleType) {};

      bool operator==(const Key& rhs) const
      {
         switch (myType)
         {
         case IntType:
            return myInt == rhs.myInt;
            break;
         case DoubleType:
            return myDbl == rhs.myDbl;
            break;
         case StrType:
         default:
            return myStr == rhs.myStr;
            break;
         }
      }

      bool operator<(const Key& rhs) const
      {
         switch (myType)
         {
         case IntType:
            return myInt < rhs.myInt;
            break;
         case DoubleType:
            return myDbl < rhs.myDbl;
            break;
         case StrType:
         default:
            return myStr < rhs.myStr;
            break;
         }
      }

      DtString string() const 
      {
         switch (myType)
         {
         case IntType:
            return DtString(myInt);
            break;
         case DoubleType:
            return DtString(myDbl);
            break;
         case StrType:
         default:
            return myStr;
            break;
         }
      }
      
      DtString myStr;
      int myInt;
      double myDbl;

      enum KeyType
      {
         StrType,
         IntType,
         DoubleType
      };
      KeyType myType;
   };


      
   virtual DtPropertyInterface* findItem(const DtString& key);

   virtual DtPropertyInterface* findItem(int key);

   virtual DtPropertyInterface* findItem(double key);

   virtual DtPropertyInterface* findItem(const Key& key);

   virtual const DtPropertyInterface* findItem(const DtString& key) const;

   virtual const DtPropertyInterface* findItem(int key) const;

   virtual const DtPropertyInterface* findItem(double key) const;

   virtual const DtPropertyInterface* findItem(const Key& key) const;

   template <typename ValueType>
   boost::optional<ValueType> findItemValue(const DtString& key) const;

   template <typename ValueType>
   boost::optional<ValueType> findItemValue(int key) const;

   template <typename ValueType>
   boost::optional<ValueType> findItemValue(double key) const;

   template <typename ValueType>
   boost::optional<ValueType> findItemValue(const Key& key) const;

      
   virtual bool insert(const DtString& key, DtPropertyInterface* item);
   virtual bool insert(int key, DtPropertyInterface* item);
   virtual bool insert(double key, DtPropertyInterface* item);
   virtual bool insert(const Key& key, DtPropertyInterface* item);

      
   virtual DtPropertyInterface* addItem(const DtString& key);
   virtual DtPropertyInterface* addItem(int key);
   virtual DtPropertyInterface* addItem(double key);
   virtual DtPropertyInterface* addItem(const Key& key);

      
   virtual bool erase(const DtString& key);
   virtual bool erase(int key);
   virtual bool erase(double key);
   virtual bool erase(const Key& key);

   DtPropertyInterface& operator[](const DtString& key);
   const DtPropertyInterface& operator[](const DtString& key) const;
   DtPropertyInterface& operator[](double key);
   const DtPropertyInterface& operator[](double key) const;
   DtPropertyInterface& operator[](int key);
   const DtPropertyInterface& operator[](int key) const;
   DtPropertyInterface& operator[](const Key& key);
   const DtPropertyInterface& operator[](const Key& key) const;

   virtual const char *readerWriterType() const override;

   static const char* theXmlType();

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

   DtRwPropertiesMap& operator=(const DtRwPropertiesMap&);

   virtual void setKeyType(const DtString&);
   virtual const DtReaderWriter* keyType() const;

   virtual bool keyIsInt() const;
   virtual bool keyIsReal() const;
   virtual bool keyIsString() const;

   virtual Key keyOfItem(const DtPropertyInterface* item) const;

   virtual std::set<Key> allKeys() const;

   virtual bool isSimilarProperty(const DtPropertyInterface *rhs,
                                  bool strict = true) const override;

   virtual int hlaAlignment() const override;

   bool operator==(const DtRwPropertiesMap&) const;

protected:

   virtual bool convertKeyToString(int key, DtString& str) const;

   virtual bool convertKeyToString(double key, DtString& str) const;

   virtual bool convertStringToKey(const DtString& str, int& key) const;

   virtual bool convertStringToKey(const DtString& str, double& key) const;

   virtual DtPropertyInterface *createPrototype(DtlObjPtr args) override;
   virtual DtlObjPtr variablesStart(DtlObjPtr args) const override;

   virtual void createListEntry(DtPropertyInterface *iFace, DtlObjPtr variableItem,
                   const DtReaderWriter::SearchPaths &searchPaths,
                   const DtVariableBindingsList &variableBindings) override;

   virtual void getSize(const DtPropertyInterface *, int &size) const override;

   virtual char *encode(const DtPropertyInterface *, char *buf) const override;

   virtual const char *decode(DtPropertyInterface *iFace,
                              const char *buf) override;

   virtual int requiredPadding(const char *buf,
                               const DtPropertyInterface *field) const override;

   virtual void writePrototype(const DtReaderWriter* rw, std::string& fp, int indentLevel, bool writeHeader) const override;

   virtual void getData(const DtEnvironmentSP env, const DtEnvValueSP root,
                        const DtReaderWriter::SearchPaths &searchPaths,
                        const DtVariableBindingsList &varBindings) override;
   virtual void putData(DtEnvironmentSP env, DtEnvValueSP value) const override;
   virtual void postWriteItem(std::string &fp, DtReaderWriter *rw,
                              int indentLevel) override;
   virtual void preWriteItem(std::string &fp, DtReaderWriter *rw,
                             int indentLevel) override;

   virtual DtPropertyInterface* scratchItem() const;

   virtual const DtPropertyInterface* findPropertyInterfaceByStringKey(const DtString& keyStr) const;
   virtual DtPropertyInterface* findPropertyInterfaceByStringKey(const DtString& keyStr);

protected:
   mutable DtPropertyInterface* myKeyType;

   mutable DtPropertyInterface* myScratchItem;
};

template <typename ValueType>
boost::optional<ValueType> DtRwPropertiesMap::findItemValue(const DtString& key) const
{
   if (keyIsString())
   {
      return findPropertyValue<ValueType>(key);
   }

   return boost::optional<ValueType>();
}

template <typename ValueType>
boost::optional<ValueType> DtRwPropertiesMap::findItemValue(int key) const
{
   DtString keyStr;
   if (convertKeyToString(key, keyStr))
   {
      return findPropertyValue<ValueType>(keyStr);
   }

   return boost::optional<ValueType>();
}

template <typename ValueType>
boost::optional<ValueType> DtRwPropertiesMap::findItemValue(double key) const
{
   DtString keyStr;
   if (convertKeyToString(key, keyStr))
   {
      return findPropertyValue<ValueType>(keyStr);
   }

   return boost::optional<ValueType>();
}

template <typename ValueType>
boost::optional<ValueType>
DtRwPropertiesMap::findItemValue(const Key& key) const
{
   return findPropertyValue<ValueType>(key.string());
}