readerWriter.h

Go to the documentation of this file.

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


#pragma once

#include "stdio.h"
#include <mtl/mtl.h>
#include <vlutil/vlString.h>
#include "vrfutil/objectCounter.h"
#include "vrfutil/readerWriterRegistry.h"
#include "vrfutil/putSelfCallbackInfo.h"
#include "vrfutil/getSelfCallbackInfo.h"
#include <vlutil/vlMachineTypes.h>
#include "tdbutil/symbolString.h"
#include <mtl/environment.h>
#include <vlutil/vlFilename.h>
#include <list>
#include "vrfutil/vrfutilDefines.h"
#include <vlutil/vlSmartPointers.h>
#include <vlutil/vlTime.h>

#include <ostream>

class DtRwVariableBindings;
class DtReaderWriterFactory;
class DtPropertyInterface;

typedef DT_DLL_vrfutil DtBoost::shared_ptr<DtEnvironment> DtEnvironmentSP;

class DT_DLL_vrfutil DtReaderWriter : public DtObjectDebugger<DtReaderWriter>
{
public:

   typedef std::vector<DtSymbolString> aliasContainer;
   typedef std::vector<DtSymbolString>::iterator aliasIter;
   typedef std::vector<DtSymbolString>::const_iterator aliasConstIter;
   typedef std::vector<DtFilename> SearchPaths;

   DtReaderWriter();

   DtReaderWriter(const DtString& name, DtReaderWriterRegistry*
      parentRegistry = NULL, bool readonly = false);
   DtReaderWriter(const DtSymbolString& name, DtReaderWriterRegistry*
      parentRegistry = NULL, bool readonly = false);

   DtReaderWriter(const DtString& name, const DtReaderWriter& orig,
      DtReaderWriterRegistry* parentRegistry = NULL);
   DtReaderWriter(const DtSymbolString& name, const DtReaderWriter& orig,
      DtReaderWriterRegistry* parentRegistry = NULL);

   explicit DtReaderWriter(const DtReaderWriter&,
      DtReaderWriterRegistry* parentRegistry = NULL);

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

   bool operator==(const DtReaderWriter&) const;

   bool operator!=(const DtReaderWriter& rhs) { return !(*this == rhs); };

   virtual ~DtReaderWriter();

   virtual void putSelf(std::string& fp, int indentLevel = 0,
      bool writeUnspecified = false, const DtFilename& path =
      DtFilename::nullFilename());

   virtual void postPutSelf();

   virtual void prePutSelf();

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

   virtual void postGetSelf();

   virtual void preGetSelf();

   virtual void writeSelf(std::string& fp, int indentLevel = 0,
      bool writeUnspecified = false,
      const DtFilename& path = DtFilename::nullFilename());


   virtual void putData(std::string& fp, int indentLevel = 0);
   virtual DtlObjPtr getData(DtlObjPtr args, const SearchPaths& searchPaths,
      const DtVariableBindingsList& variableBindings);

   virtual DtSymbolString name() const;

   static void putIndent(std::string& fp, int indentLevel);

   static const DtVariableBindingsList& nullVariableReference();


   virtual void setValueSpecified(bool specified, bool recurse = false);
   virtual bool valueSpecified() const;

   virtual void addAlias(const DtSymbolString& alias);
   virtual void addAlias(const DtString& alias);

   virtual bool hasAlias(const DtSymbolString& alias);

   virtual const aliasContainer& aliases() const;

   virtual void setReadonly(bool flag);

   inline bool isReadonly() const
   {
      return myReadOnlyFlag;
   }

   virtual void reset();


   virtual bool isVariableReference() const;
   virtual void setIsVariableReference(bool value);

   virtual void clearAllVariableReferenceFlags();


   virtual int alignment() const;


   virtual DtSymbolString variableName() const;
   virtual void setVariableName(const DtSymbolString variableName);

   virtual const DtReaderWriter* defaultRWValue() const;
   virtual DtReaderWriter* defaultRWValue();

   virtual void setDefaultRWValue(DtReaderWriter*);

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

   virtual DtString toXml() const;

   static DtReaderWriter* createFromXmlFile(const DtFilename&, bool createAsProperty = false);

   static DtReaderWriter* createFromXml(const DtString&, bool createAsProperty = false);

   static DtReaderWriter* createFromEnvironment(DtEnvironmentSP, bool createAsProperty = false);

   virtual bool toXml(const DtFilename&) const;

   virtual bool fromXml(const DtString&);

   virtual bool fromXmlFile(const DtFilename&);
   virtual void putSelf(DtEnvironmentSP, DtEnvValueSP parent) const;

   static DtString getAttribute(DtEnvironmentSP env, const DtString& name, DtEnvValueSP root);

   virtual void putData(DtEnvironmentSP, DtEnvValueSP value) const;

   virtual void putVariableReference(DtEnvironmentSP, DtEnvValueSP value) const;

   virtual void getSelf(const DtEnvironmentSP, const DtEnvValueSP root,
      const SearchPaths& searchPaths = SearchPaths(), 
      const DtVariableBindingsList& bindings = DtVariableBindingsList());

   virtual void getData(const DtEnvironmentSP, const DtEnvValueSP,
      const SearchPaths& searchPaths = SearchPaths(), 
      const DtVariableBindingsList& bindings = DtVariableBindingsList());

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

   virtual void getVariableReference(DtEnvironmentSP, DtEnvValueSP value);


   virtual bool variableIsBound() const;
   virtual void unbindVariable();

   static void setPostGetSelfCallback(DtGetSelfCallbackFcn fcn, void* usrData);
   static void setPrePutSelfCallback(DtPutSelfCallbackFcn fcn, void* usrData);

   static void setPutIndent(bool);
   static bool putIndent();


   const DtReaderWriterRegistry& registry() const;
   DtReaderWriterRegistry& registry();

   virtual void setName(const DtString&);

   virtual const char* readerWriterType() const;

   static const char* theXmlType();

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

   virtual DtString prettyPrint() const;

   std::string debugText() const;

   virtual void bindVariables(DtVariableBindingsList variableBindings);

   typedef std::pair<DtSymbolString, DtString> DtVariableNameType;
   virtual std::list<DtVariableNameType> unboundVariables() const;
   
   static const DtFilename& appPath();

   bool invalid() const;

   virtual bool hasChild(const DtReaderWriter* p) const;

   typedef DtReaderWriterFactory* (*DtReaderWriterFactoryCreatorFcn)();

   static void setFactoryCreatorFunction(DtReaderWriterFactoryCreatorFcn fcn);

   static void createReaderWriterFactory();
   static void cleanupFactory();

   static DtReaderWriterFactory* factory();

   virtual bool hasVariableReference() const;

   virtual void bindLocalVariables(const DtVariableBindingsList& variableBindings);
   
   virtual DtPropertyInterface* property();
   virtual const DtPropertyInterface* property() const;

   virtual void recordUpdateTime() const {}

   virtual bool wasUpdatedSince(DtTime t) const { return true; }


protected:
   virtual void bindToRwAsVariable(const DtReaderWriter* rw);

protected:

   const DtSymbolString myName;
   DtReaderWriterRegistry myRegistry;
   DtReaderWriterRegistry* myParentRegistry;
   bool myValueSpecified;
   bool myReadOnlyFlag;
   bool myIsVariableReference;
   DtSymbolString myVariableName;
   bool myVariableIsBound;

   DtReaderWriter*   myDefaultValue;

   aliasContainer myAliases;

   static DtString theUnspecifiedValue;

   static DtGetSelfCallbackInfo thePostGetSelfCallback;
   static DtPutSelfCallbackInfo thePrePutSelfCallback;
   static const DtVariableBindingsList theEmptyVariableBindingsList;

   static bool theCreatorFcnSet;
   static DtReaderWriterFactory* theFactory;
   static DtReaderWriterFactoryCreatorFcn theFactoryCreatorFcn;
   static bool thePutIndent;

   bool  myInvalid;
};

inline const DtReaderWriterRegistry& DtReaderWriter::registry() const
{
   return myRegistry;
}

inline DtReaderWriterRegistry& DtReaderWriter::registry()
{
   return myRegistry;
}

inline bool DtReaderWriter::invalid() const
{
   return myInvalid;
}

DT_DEFINE_OBJECT_DEBUGGER_NAME(DtReaderWriter);

inline std::string& operator<<(std::string& a, const std::string& b) { a += b; return a; }
inline std::string& operator<<(std::string& a, const char* b) { a += b; return a; }
inline std::string& operator<<(std::string& a, char b) { a += b; return a; }
DT_DLL_vrfutil std::string& operator<<(std::string&, int);
DT_DLL_vrfutil std::string& operator<<(std::string&, unsigned int);
DT_DLL_vrfutil std::string& operator<<(std::string&, double);
DT_DLL_vrfutil std::string& operator<<(std::string&, float);