rwProperties.h

Go to the documentation of this file.

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


#pragma once

#include <readerWriter/rwVariableBindings.h>
#include <vlutil/vlString.h>
#include <readerWriter/readerWriterFactory.h>
#include <readerWriter/propertyInterface.h>
#include <tbb/spin_mutex.h>

class DtRwProperties;

class DT_DLL_readerWriter DtPropertiesIterator
{
public:

   DtPropertiesIterator();
   DtPropertiesIterator(DtRwProperties*);
   DtPropertiesIterator(const DtPropertiesIterator&);

   ~DtPropertiesIterator();

   bool operator==(const DtPropertiesIterator& other) const;
   bool operator!=(const DtPropertiesIterator& other) const;

   DtPropertiesIterator& operator=(const DtPropertiesIterator& other);

   DtPropertiesIterator& operator++();
   DtPropertiesIterator operator++(int);
   DtPropertiesIterator& operator--();
   DtPropertiesIterator operator--(int);

   DtPropertyInterface& operator*();
   DtPropertyInterface* operator->();

   DtPropertyInterface* property();
   const DtPropertyInterface* property() const;

   template <typename KeyType>
   KeyType key() const;

   const DtRwProperties* properties() const;

   void setRegistryIterator(std::vector<DtReaderWriterRegistryData*>::iterator iter);

   std::vector<DtReaderWriterRegistryData*>::iterator registryIterator() const;

protected:

   DtRwProperties* myProperties;
   std::vector<DtReaderWriterRegistryData*>::iterator myRegIter;
};

class DT_DLL_readerWriter DtPropertiesConstIterator
{
public:

   DtPropertiesConstIterator();
   DtPropertiesConstIterator(const DtRwProperties*);
   DtPropertiesConstIterator(const DtPropertiesConstIterator&);
   DtPropertiesConstIterator(const DtPropertiesIterator&);

   ~DtPropertiesConstIterator();

   bool operator==(const DtPropertiesConstIterator& other) const;
   bool operator!=(const DtPropertiesConstIterator& other) const;

   DtPropertiesConstIterator& operator=(const DtPropertiesConstIterator& other);
   DtPropertiesConstIterator& operator=(const DtPropertiesIterator& other);

   DtPropertiesConstIterator& operator++();
   DtPropertiesConstIterator operator++(int);
   DtPropertiesConstIterator& operator--();
   DtPropertiesConstIterator operator--(int);

   const DtPropertyInterface& operator*() const;
   const DtPropertyInterface* operator->() const;

   const DtPropertyInterface* property() const;

   template <typename KeyType>
   KeyType key() const;

   const DtRwProperties* properties() const;

   void setRegistryIterator(std::vector<DtReaderWriterRegistryData*>::const_iterator iter);

   std::vector<DtReaderWriterRegistryData*>::const_iterator registryIterator() const;

protected:

   const DtRwProperties* myProperties;
   std::vector<DtReaderWriterRegistryData*>::const_iterator myRegIter;
};

class DT_DLL_readerWriter DtRwProperties : public DtRwVariableBindings, public DtPropertyInterface
{
private:
   DtRwProperties();

public:

   typedef DtPropertiesIterator iterator;
   typedef DtPropertiesConstIterator const_iterator;

   DtRwProperties(const DtString& name, DtReaderWriterRegistry* parentRegistry = 0);
   DtRwProperties(const DtString& name, const DtRwProperties& orig,
      DtReaderWriterRegistry* parentRegistry = 0);
   DtRwProperties(const DtRwProperties& orig,
      DtReaderWriterRegistry* parentRegistry = 0);

   DtRwProperties& operator=(const DtRwProperties& orig);
   virtual ~DtRwProperties() override;

   virtual const_iterator begin() const;
   virtual iterator begin();

   virtual const_iterator end() const;
   virtual iterator end();

   virtual unsigned size() const;

   virtual const DtPropertyInterface *
   findPropertyInterface(const DtString &propertyName) const override;
   virtual DtPropertyInterface *
   findPropertyInterface(const DtString &propertyName) override;

   virtual bool addProperty(DtPropertyInterface *) override;

   virtual bool addPropertyAtIndex(DtPropertyInterface*, unsigned index);

   virtual bool removeProperty(const DtString &propertyName) override;
   virtual bool removeProperty(const DtPropertyInterface *property) override;

   virtual void copy(const DtPropertyInterface &rhs) override;

   virtual void getSelf(DtlObjPtr args,
           const DtReaderWriter::SearchPaths &searchPaths = SearchPaths(),
           const DtVariableBindingsList &variableBindings =
               nullVariableReference()) override;
   virtual DtlObjPtr getData(DtlObjPtr args,
           const DtReaderWriter::SearchPaths &searchPaths = SearchPaths(),
           const DtVariableBindingsList &variableBindings =
               nullVariableReference()) override;

   virtual const char *readerWriterType() const override;

   virtual bool isValidProperty(const DtPropertyInterface*) const;

   virtual DtPropertyInterface* createProperty(DtlObjPtr args, DtReaderWriterRegistry* parentRegistry);

   virtual char *encode(char *) const override;

   virtual const char *decode(const char *) override;

   virtual void getSize(int &size) const override;

   static DtReaderWriterPropertyFactory* propertyFactory();
   static void cleanupPropertyFactory();

   virtual void copyVariables(const DtRwVariableBindings &other) override;

   virtual bool isReadonly() const;

   virtual int hlaAlignment() const override;

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

   virtual const char *propertyType() const override;

   virtual int count() const;

   virtual const DtReaderWriter* findPropertyRw(const DtString& propName) const;
   virtual DtReaderWriter* findPropertyRw(const DtString& propName);

   virtual DtString stringRep(const DtString &root = "") const override;

   virtual bool merge(const DtPropertyInterface &target, MergeFlags,
         const DtMergePath &path = DtMergePath(),
         const std::set<DtString> &ignore = std::set<DtString>()) override;

   virtual DtRwProperties createFromPercentages(const DtRwProperties& percentages, const DtRwProperties& baseValues,
      const DtString& base = "Base-");

   virtual bool findRootAndVariable(const DtString& varName, DtReaderWriter*& root, DtReaderWriter*& variable) const;
   
   virtual DtReaderWriter *readerWriter() override;
   virtual const DtReaderWriter *readerWriter() const override;

   virtual DtPropertyInterface *property() override;
   virtual const DtPropertyInterface *property() const override;

   virtual DtSymbolString propertyName() const override { return name(); };

   virtual void setPropertyName(const DtString &propertyName) override { setName(propertyName); };

   virtual bool isUpdateNeeded(DtTime t) const override;

   virtual bool hasReceivedUpdateSince(DtTime t) const override;

   virtual DtTime updateClockTime() const override;

   virtual bool isPublished() const override;
   virtual void setIsPublished(bool isPub) override;

   virtual unsigned disRecordType() const override;
   virtual void setDisRecordType(unsigned recType) override;

   virtual void clearVariables() override;

   virtual void reset() override;

   virtual void removeVariable(DtReaderWriter *) override;
   virtual void removeVariable(const DtReaderWriter *) override;

   virtual void invalidateCache();

   virtual void invalidateCacheForProperty(const DtString& propName);

   static const DtRwProperties& emptyProperties();


   static bool rollUpInteger(const DtReaderWriter* source, DtReaderWriter* destination, const DtMergePath& path);

   static bool rollUpReal(const DtReaderWriter* source, DtReaderWriter* destination, const DtMergePath& path);

   static bool rollUpString(const DtReaderWriter* source, DtReaderWriter* destination, const DtMergePath& path);

   static bool rollUpBoolean(const DtReaderWriter* source, DtReaderWriter* destination, const DtMergePath& path);

   virtual bool setWritePrototypeHeader(bool);
   virtual bool writePrototypeHeader() const;

   virtual void cloneAndAddProperty(const DtReaderWriter& rw);

   virtual void setKeepPublishingSettings(bool keep) override;
   virtual bool keepPublishingSettings() const override;

protected:
   virtual void filterIgnoredProperties(DtReaderWriter* rw, const std::set<DtString>& ignore);

   virtual void getInterface(DtPropertyInterface* pFace, DtlObjPtr args, 
      const DtReaderWriter::SearchPaths& searchPaths = SearchPaths(),
      const DtVariableBindingsList& variableBindings = nullVariableReference());

   virtual void writeSelf(std::string &fp, int indentLevel,
                          bool writeUnspecified,
                          const DtFilename &path) override;
   virtual void writeData(std::string& fp, int indentLevel, bool writeUnspecified, const DtFilename& path);

   virtual void putData(std::string &, int indentLevel = 0) override;

   virtual int hlaAlignment(const DtPropertyInterface* field) const;

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

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

   virtual void unrecognizedItem(const DtEnvironmentSP env, const DtEnvValueSP root,
                    const DtReaderWriter::SearchPaths &searchPaths,
                    const DtVariableBindingsList &varBindings) override;

   virtual bool traverseAndModifyPercentage(DtRwProperties& results, const DtRwProperties& baseValues,
      const DtReaderWriter* percentage, const DtString& base) const;

   virtual void writePrototypeHeader(std::string& fp, const DtReaderWriter* rw, int indentLevel) const;

   virtual void writePropertyData(DtReaderWriter* rw, std::string& fp, int indentLevel, bool writeUnspecified, const DtFilename& path);

   virtual void getSortedProperties(const DtRwVariableBindings& varBindings, std::vector<const DtReaderWriter*>& propertyList) const;
   virtual void getSortedProperties(DtRwVariableBindings& varBindings, std::vector<DtReaderWriter*>& propertyList);

   virtual bool isDebugEnabled() const override;
   virtual void setDebugEnabled(bool en) override;

   virtual void writePublishInformation(std::string& fp, int indentLevel) override;

protected:
   static DtReaderWriterPropertyFactory* thePropertyFactory;

   mutable std::multimap<DtString, DtReaderWriter*> myRwPropertyCache;
   mutable tbb::spin_mutex* myCacheMutex;

   DtClock myClock;

   mutable DtTime myLastTimeSizeChanged;

   mutable int mySizeAtLastCheck;

   unsigned myDisRecordType;

   bool myIsPublished;

   bool myWritePrototypeHeader;

   bool myDebugEnabled;

   bool myKeepPublishingSettingsOnCopy;

   mutable DtPropertyInterface* myPreviousParentProp;
   mutable DtString myPreviousParentPropFullName;
};

template <typename KeyType>
KeyType DtPropertiesIterator::key() const
{
   DtWarn << "Could not convert key, \"" << property()->propertyName() 
      << "\", to the specified type." << std::endl;

   return KeyType();
}

template <>
inline int DtPropertiesIterator::key<int>() const
{
   bool ok = false;
   DtString keyStr(property()->propertyName().string());
   int result = keyStr.toInt(&ok);

   if (!ok)
   {
      DtWarn << "Could not convert key, \"" << property()->propertyName()
         << "\", to an int." << std::endl;
   }

   return result;
}

template <>
inline double DtPropertiesIterator::key<double>() const
{
   bool ok = false;
   DtString keyStr(property()->propertyName().string());
   int result = keyStr.toDouble(&ok);

   if (!ok)
   {
      DtWarn << "Could not convert key, \"" << property()->propertyName()
         << "\", to an double." << std::endl;
   }

   return result;
}

template <>
inline DtString DtPropertiesIterator::key<DtString>() const
{
   return property()->propertyName().string();
}

template <>
inline std::string DtPropertiesIterator::key<std::string>() const
{
   return property()->propertyName().string();
}

template <typename KeyType>
KeyType DtPropertiesConstIterator::key() const
{
   DtWarn << "Could not convert key, \"" << property()->propertyName()
      << "\", to the specified type." << std::endl;
}

template <>
inline int DtPropertiesConstIterator::key<int>() const
{
   bool ok = false;
   DtString keyStr(property()->propertyName().string());
   int result = keyStr.toInt(&ok);

   if (!ok)
   {
      DtWarn << "Could not convert key, \"" << property()->propertyName()
         << "\", to an int." << std::endl;
   }

   return result;
}

template <>
inline double DtPropertiesConstIterator::key<double>() const
{
   bool ok = false;
   DtString keyStr(property()->propertyName().string());
   int result = keyStr.toDouble(&ok);

   if (!ok)
   {
      DtWarn << "Could not convert key, \"" << property()->propertyName()
         << "\", to an double." << std::endl;
   }

   return result;
}

template <>
inline DtString DtPropertiesConstIterator::key<DtString>() const
{
   return property()->propertyName().string();
}

template <>
inline std::string DtPropertiesConstIterator::key<std::string>() const
{
   return property()->propertyName().string();
}