rwProperties.h

Go to the documentation of this file.

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


#pragma once

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

namespace tbb
{
   class spin_mutex;
}

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();

   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;
   virtual DtPropertyInterface* findPropertyInterface(const DtString& propertyName);

   virtual bool addProperty(DtPropertyInterface*);

   virtual bool addPropertyAtIndex(DtPropertyInterface*, unsigned index);

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

   virtual void copy(const DtPropertyInterface& rhs);

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

   virtual const char* readerWriterType() const;

   virtual bool isValidProperty(const DtPropertyInterface*) const;

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

   virtual char* encode(char*) const;

   virtual const char* decode(const char*);

   virtual void getSize(int& size) const;

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

   virtual void copyVariables(const DtRwVariableBindings& other);

   virtual bool isReadonly() const;

   virtual int hlaAlignment() const;

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

   virtual const char* propertyType() const;

   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;

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

   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();
   virtual const DtReaderWriter* readerWriter() const;

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

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

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

   virtual bool wasUpdatedSince(DtTime t) const;

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

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

   virtual void clearVariables();

   virtual void reset();

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

   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);

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);
   virtual void writeData(std::string& fp, int indentLevel, bool writeUnspecified, const DtFilename& path);

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

   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);

   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;
   virtual void setDebugEnabled(bool en);

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;

   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 <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();
}