propertyInterface.h

Go to the documentation of this file.

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


#pragma once

#include <vrfutil/vrfutilDefines.h>
#include <vrfutil/rwBoolean.h>
#include <vrfutil/rwString.h>
#include <vrfutil/rwInt.h>
#include <vrfutil/rwReal.h>
#include <vrfutil/rwVector.h>
#include <vrfutil/readerWriterFactory.h>
#include <vlutil/vlTime.h>

#include <string>

class DtPropertyInterface
{
public:
   enum MergeFlags
   {
      Replace = 0x00000001,   
      MinimalSimilarityCheck = 0x00000002, 
      RollUp = 0x00000004,    


      AddMissing = 0x00000008,
      KeepIsPublished = 0x00000010 
   };

   virtual ~DtPropertyInterface() {};

   virtual char* encode(char*) const = 0;

   virtual const char* decode(const char*) = 0;

   virtual void getSize(int& size) const = 0;

   virtual int hlaAlignment() const = 0;

   virtual const char* propertyType() const = 0;

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

   int getSize() const
   {
      int size = 0;
      getSize(size);

      return size;
   }

   virtual DtReaderWriter* readerWriter() = 0;
   virtual const DtReaderWriter* readerWriter() const = 0;

   virtual bool isSimilarProperty(const DtPropertyInterface* rhs) const
   {
      return (std::string(rhs->propertyType()) == std::string(propertyType()));
   }

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

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

   virtual bool isPublishedArg(DtlObjPtr arg, unsigned& disVarRecType) const
   {
      bool isPub = false;
      disVarRecType = 0;

      if (!DtcNull(arg))
      {
         if (arg->tag() == DtpSymbol)
         {
            DtString pn(arg->pname());
            pn.toLower();
            if (pn == "publish")
            {
               isPub = true;
            }
         }
         else if (arg->tag() == DtpList)
         {
            DtlObjPtr pub = DtcCar(arg);
            if (!DtcNull(pub) && pub->tag() == DtpSymbol)
            {
               DtString pn(pub->pname());
               pn.toLower();
               if (pn == "publish")
               {
                  isPub = true;

                  DtlObjPtr recType = DtcCadr(arg);
                  if (!DtcNull(recType) && recType->tag() == DtpFix)
                  {
                     disVarRecType = recType->fixnum();
                  }
               }
            }
         }
      }

      return isPub;
   }

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

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

   virtual void reset() = 0;
};

template <typename _RwType>
class DtRwProperty : public _RwType, public DtPropertyInterface
{
private:
   DtRwProperty();

public:

   DtRwProperty(const DtString& name, DtReaderWriterRegistry* parentRegistry = 0);
   DtRwProperty(const DtString& name, const DtRwProperty& orig,
      DtReaderWriterRegistry* parentRegistry = 0);
   DtRwProperty& operator=(const DtRwProperty& orig);
   virtual ~DtRwProperty();

   virtual char* encode(char*) const;

   virtual const char* decode(const char*);

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

   virtual void getSize(int& size) const;

   virtual int hlaAlignment() const;

   virtual const char* propertyType() const;

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

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

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

   virtual DtReaderWriter* readerWriter();
   virtual const DtReaderWriter* readerWriter() const;

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

   virtual void recordUpdateTime() const;

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

protected:

   DtClock myClock;
   mutable DtTime myUpdateTime;
   bool myIsPublished;
   unsigned myDisRecordType;
};

template <typename _RwType>
class DtRwPropertyWithThreshold : public DtRwProperty<_RwType>
{
private:
   DtRwPropertyWithThreshold();

public:

   DtRwPropertyWithThreshold(const DtString& name, DtReaderWriterRegistry* parentRegistry = 0);
   DtRwPropertyWithThreshold(const DtString& name, const DtRwPropertyWithThreshold& orig,
      DtReaderWriterRegistry* parentRegistry = 0);
   DtRwPropertyWithThreshold& operator=(const DtRwPropertyWithThreshold& orig);
   virtual ~DtRwPropertyWithThreshold();

   virtual char* encode(char*) const;

   virtual bool wasUpdatedSince(DtTime t) const;

   virtual void enableThresholding(bool enable);

   virtual void setThreshold(double percentage);

   static void setDefaultThreshold(double percentage);

   virtual void setMaxUpdateInterval(DtTime interval);

   static void setDefaultMaxUpdateInterval(DtTime interval);

   virtual void setMaxUnchangedUpdateInterval(DtTime interval);

   static void setDefaultMaxUnchangedUpdateInterval(DtTime interval);

protected:

   bool myThresholdingEnabled;

   mutable _RwType myLastEncodedValue;

   mutable DtTime myLastEncodeTime;

   static double myDefaultThreshold;
   double myThreshold;

   static DtTime myDefaultMaxUpdateInterval;
   DtTime myMaxUpdateInterval;

   static DtTime myDefaultMaxUnchangedUpdateInterval;
   DtTime myMaxUnchangedUpdateInterval;
};

class DT_DLL_vrfutil DtRwPropertyString : public DtRwProperty<DtRwString>
{
public:
   DtRwPropertyString(const DtString& name, DtReaderWriterRegistry* parentRegistry = 0);
   DtRwPropertyString(const DtString& name, const DtRwPropertyString& orig,
      DtReaderWriterRegistry* parentRegistry = 0);
   DtRwPropertyString(const DtRwPropertyString& orig,
      DtReaderWriterRegistry* parentRegistry = 0);

   DtRwPropertyString& operator=(const DtRwPropertyString& orig);

   virtual ~DtRwPropertyString();
};

class DT_DLL_vrfutil DtRwPropertyBoolean : public DtRwProperty<DtRwBoolean>
{
public:
   DtRwPropertyBoolean(const DtString& name, DtReaderWriterRegistry* parentRegistry = 0);
   DtRwPropertyBoolean(const DtString& name, const DtRwPropertyBoolean& orig,
      DtReaderWriterRegistry* parentRegistry = 0);
   DtRwPropertyBoolean(const DtRwPropertyBoolean& orig,
      DtReaderWriterRegistry* parentRegistry = 0);
   DtRwPropertyBoolean& operator=(const DtRwPropertyBoolean& orig);
   virtual ~DtRwPropertyBoolean();
};

class DT_DLL_vrfutil DtRwPropertyInt : public DtRwPropertyWithThreshold<DtRwInt>
{
public:
   DtRwPropertyInt(const DtString& name, DtReaderWriterRegistry* parentRegistry = 0);
   DtRwPropertyInt(const DtString& name, const DtRwPropertyInt& orig,
      DtReaderWriterRegistry* parentRegistry = 0);
   DtRwPropertyInt(const DtRwPropertyInt& orig,
      DtReaderWriterRegistry* parentRegistry = 0);
   DtRwPropertyInt& operator=(const DtRwPropertyInt& orig);
   virtual ~DtRwPropertyInt();
};

class DT_DLL_vrfutil DtRwPropertyInt8 : public DtRwPropertyWithThreshold < DtRwInt8 >
{
public:
   DtRwPropertyInt8(const DtString& name, DtReaderWriterRegistry* parentRegistry = 0);
   DtRwPropertyInt8(const DtString& name, const DtRwPropertyInt8& orig,
      DtReaderWriterRegistry* parentRegistry = 0);
   DtRwPropertyInt8(const DtRwPropertyInt8& orig,
      DtReaderWriterRegistry* parentRegistry = 0);
   DtRwPropertyInt8& operator=(const DtRwPropertyInt8& orig);
   virtual ~DtRwPropertyInt8();
};

class DT_DLL_vrfutil DtRwPropertyInt16 : public DtRwPropertyWithThreshold < DtRwInt16 >
{
public:
   DtRwPropertyInt16(const DtString& name, DtReaderWriterRegistry* parentRegistry = 0);
   DtRwPropertyInt16(const DtString& name, const DtRwPropertyInt16& orig,
      DtReaderWriterRegistry* parentRegistry = 0);
   DtRwPropertyInt16(const DtRwPropertyInt16& orig,
      DtReaderWriterRegistry* parentRegistry = 0);
   DtRwPropertyInt16& operator=(const DtRwPropertyInt16& orig);
   virtual ~DtRwPropertyInt16();
};

class DT_DLL_vrfutil DtRwPropertyInt32 : public DtRwPropertyWithThreshold < DtRwInt32 >
{
public:
   DtRwPropertyInt32(const DtString& name, DtReaderWriterRegistry* parentRegistry = 0);
   DtRwPropertyInt32(const DtString& name, const DtRwPropertyInt32& orig,
      DtReaderWriterRegistry* parentRegistry = 0);
   DtRwPropertyInt32(const DtRwPropertyInt32& orig,
      DtReaderWriterRegistry* parentRegistry = 0);
   DtRwPropertyInt32& operator=(const DtRwPropertyInt32& orig);
   virtual ~DtRwPropertyInt32();
};

class DT_DLL_vrfutil DtRwPropertyReal : public DtRwPropertyWithThreshold<DtRwReal>
{
public:
   DtRwPropertyReal(const DtString& name, DtReaderWriterRegistry* parentRegistry = 0);
   DtRwPropertyReal(const DtString& name, const DtRwPropertyReal& orig,
      DtReaderWriterRegistry* parentRegistry = 0);
   DtRwPropertyReal(const DtRwPropertyReal& orig,
      DtReaderWriterRegistry* parentRegistry = 0);
   DtRwPropertyReal& operator=(const DtRwPropertyReal& orig);
   virtual ~DtRwPropertyReal();
};

class DT_DLL_vrfutil DtRwPropertyReal32 : public DtRwPropertyWithThreshold < DtRwReal32 >
{
public:
   DtRwPropertyReal32(const DtString& name, DtReaderWriterRegistry* parentRegistry = 0);
   DtRwPropertyReal32(const DtString& name, const DtRwPropertyReal32& orig,
      DtReaderWriterRegistry* parentRegistry = 0);
   DtRwPropertyReal32(const DtRwPropertyReal32& orig,
      DtReaderWriterRegistry* parentRegistry = 0);
   DtRwPropertyReal32& operator=(const DtRwPropertyReal32& orig);
   virtual ~DtRwPropertyReal32();
};

class DT_DLL_vrfutil DtRwPropertyReal64 : public DtRwPropertyWithThreshold < DtRwReal64 >
{
public:
   DtRwPropertyReal64(const DtString& name, DtReaderWriterRegistry* parentRegistry = 0);
   DtRwPropertyReal64(const DtString& name, const DtRwPropertyReal64& orig,
      DtReaderWriterRegistry* parentRegistry = 0);
   DtRwPropertyReal64(const DtRwPropertyReal64& orig,
      DtReaderWriterRegistry* parentRegistry = 0);
   DtRwPropertyReal64& operator=(const DtRwPropertyReal64& orig);
   virtual ~DtRwPropertyReal64();
};

class DT_DLL_vrfutil DtRwPropertyVector : public DtRwPropertyWithThreshold<DtRwVector>
{
public:
   DtRwPropertyVector(const DtString& name, DtReaderWriterRegistry* parentRegistry = 0);
   DtRwPropertyVector(const DtString& name, const DtRwPropertyVector& orig,
      DtReaderWriterRegistry* parentRegistry = 0);
   DtRwPropertyVector(const DtRwPropertyVector& orig,
      DtReaderWriterRegistry* parentRegistry = 0);
   DtRwPropertyVector& operator=(const DtRwPropertyVector& orig);
   virtual ~DtRwPropertyVector();
};


class DT_DLL_vrfutil DtRwPropertyOffsetVector : public DtRwPropertyWithThreshold<DtRwOffsetVector>
{
public:
   DtRwPropertyOffsetVector(const DtString& name, DtReaderWriterRegistry* parentRegistry = 0);
   DtRwPropertyOffsetVector(const DtString& name, const DtRwPropertyOffsetVector& orig,
      DtReaderWriterRegistry* parentRegistry = 0);
   DtRwPropertyOffsetVector(const DtRwPropertyOffsetVector& orig,
      DtReaderWriterRegistry* parentRegistry = 0);
   DtRwPropertyOffsetVector& operator=(const DtRwPropertyOffsetVector& orig);
   virtual ~DtRwPropertyOffsetVector();
};