variableParameterBuilder.h

Go to the documentation of this file.

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


#pragma once

#include <vrfLua/vrfLuaDefines.h>
#include <vrfLua/propertySetter.h>
#include <vlutil/vlString.h>
#include <vrfutil/readerWriter.h>
#include <vrfutil/rwString.h>
#include <vrfutil/rwReal.h>
#include <vrfutil/rwInt.h>
#include <vrfutil/readerWriterFactory.h>
#include <vrfutil/readerWriterRegistryData.h>

#include <luabind/luabind.hpp>
#include <stdexcept>
#include <vector>
#include <set>

class DT_DLL_vrfLua DtVariableParameterInterface
{
public:
   DtVariableParameterInterface()
   {
   }

   virtual ~DtVariableParameterInterface()
   {
   }

public:
   virtual DtVariableParameterInterface* clone() const = 0;

   virtual void process(const std::string&, luabind::object const& parameters) = 0;

   virtual bool isValid() const = 0;

   virtual bool specified() const = 0;
};

template <typename _Container>
class DtVariableParameter : public DtVariableParameterInterface
{
public:
   DtVariableParameter(bool required = false)
   : myRequired(required)
   , mySpecified(false)
   {
   }

   DtVariableParameter(const DtVariableParameter& orig)
   : myRequired(orig.myRequired)
   , mySpecified(orig.mySpecified)
   , myValue(orig.myValue)
   {
   }

   virtual ~DtVariableParameter()
   {
   }

   virtual DtVariableParameterInterface* clone() const
   {
      return new DtVariableParameter<_Container>(*this);
   }

   virtual void process(const std::string& parameter, luabind::object const& parameters)
   {
      luabind::object tableEntry = parameters[parameter];
      if (tableEntry.is_valid())
      {
         if (luabind::type(tableEntry) != LUA_TNIL)
         {
            myValue = luabind::object_cast<_Container>(tableEntry);
            mySpecified = true;
         }
      }
   }

   const _Container& value() const
   {
      return myValue;
   }

   void setValue(const _Container& value)
   {
      myValue = value;
      mySpecified = true;
   }

   virtual bool specified() const
   {
      return mySpecified;
   }

   bool required() const
   {
      return myRequired;
   }

   virtual bool isValid() const
   {
      return (!myRequired || (myRequired && mySpecified));
   }

protected:
   _Container myValue;
   bool myRequired;
   bool mySpecified;
};

template <typename _Container>
class DtVariableParameterVector : public DtVariableParameter<std::vector<_Container> >
{
public:
   DtVariableParameterVector(bool required = false)
   : DtVariableParameter<std::vector<_Container> >(required)
   {
   }

   DtVariableParameterVector(const DtVariableParameterVector& orig)
   : DtVariableParameter<std::vector<_Container> >(orig)
   {
   }

   virtual ~DtVariableParameterVector()
   {
   }

   virtual DtVariableParameterInterface* clone() const
   {
      return new DtVariableParameterVector<_Container>(*this);
   }

   virtual void process(const std::string& parameter, luabind::object const& parameters)
   {
      luabind::object tableEntry = parameters[parameter];
      if (tableEntry.is_valid())
      {
         if (luabind::type(tableEntry) == LUA_TTABLE)
         {
            for (luabind::iterator paramItr(tableEntry), end; paramItr != end; ++paramItr)
            {
               _Container value = luabind::object_cast<_Container>(*paramItr);
               this->myValue.push_back(value);
            }

            this->mySpecified = true;
         }
      }
   }
};


template <typename _Container>
class DtVariableParameterReaderWriter : public DtVariableParameter<_Container*>
{
public:
   DtVariableParameterReaderWriter(bool required = false)
   : DtVariableParameter<_Container*>(required)
   {
      this->myValue = 0;
   }

   DtVariableParameterReaderWriter(const DtVariableParameterReaderWriter& orig)
   : DtVariableParameter<_Container*>(orig)
   {
      if (orig.myValue)
      {
         this->myValue = DtReaderWriter::factory()->cloneReaderWriter(orig.myValue->name().c_str(),
            orig.myValue, 0);
      }
      else
      {
         this->myValue = 0;
      }
   }

   virtual ~DtVariableParameterReaderWriter()
   {
      delete this->myValue;
   }

   virtual DtVariableParameterInterface* clone() const
   {
      return new DtVariableParameterReaderWriter<_Container>(*this);
   }

   virtual DtReaderWriter* createRwStructure(DtReaderWriter* parentRw, luabind::object const& tableEntry) const
   {
      DtReaderWriter* createdRw = 0;
      for (luabind::iterator paramItr(tableEntry), end; paramItr != end; ++paramItr)
      {
         DtReaderWriterRegistry* parentReg = 0;
         if(parentRw)
         {
            parentReg = &parentRw->registry();
         }

         createdRw = DtReaderWriter::factory()->createItem(luabind::object_cast<std::string>(paramItr.key()).c_str(),
            DtString(""), parentReg);

         if (createdRw)
         {
            DtPropertySetter::setRwFromLua(*paramItr, createdRw);
         }
         else
         {
            if (luabind::type(*paramItr) == LUA_TSTRING)
            {
               DtRwString* createdRw = new DtRwString(luabind::object_cast<std::string>(paramItr.key()).c_str(), parentReg);

               *createdRw = luabind::object_cast<std::string>(*paramItr).c_str();
            }
            else if (luabind::type(*paramItr) == LUA_TNUMBER)
            {
               DtRwReal* createdRw = new DtRwReal(luabind::object_cast<std::string>(paramItr.key()).c_str(), parentReg);

               *createdRw = luabind::object_cast<double>(*paramItr);
            }
            else if (luabind::type(*paramItr) == LUA_TTABLE)
            {
               DtReaderWriter tmpRw("");

               createRwStructure(&tmpRw, *paramItr);

               if (tmpRw.registry().registryData().size())
               {
                  createdRw = tmpRw.registry().registryData()[0]->readerWriter();

                  tmpRw.registry().removeEntry(createdRw);

                  createdRw->setName(luabind::object_cast<std::string>(paramItr.key()).c_str());
                  if(parentRw)
                  {
                     parentRw->registry().addEntry(createdRw->name(), createdRw);
                  }
               }
            }
         }
      }

      return createdRw;
   }

   virtual void process(const std::string& parameter, luabind::object const& parameters)
   {
      delete this->myValue;
      this->myValue = 0;

      luabind::object tableEntry = parameters[parameter];
      if (tableEntry.is_valid())
      {
         if (luabind::type(tableEntry) == LUA_TTABLE)
         {
            this->myValue = createRwStructure(0, tableEntry);

            this->mySpecified = true;
         }
      }
   }
};

class DtVariableParameterNumberOrString : public DtVariableParameter<DtString>
{
public:
   DtVariableParameterNumberOrString(bool required = false)
   : DtVariableParameter<DtString>(required)
   {
   }

   DtVariableParameterNumberOrString(const DtVariableParameterNumberOrString& orig)
   : DtVariableParameter<DtString>(orig)
   {
   }

   virtual ~DtVariableParameterNumberOrString()
   {
   }

   virtual DtVariableParameterInterface* clone() const
   {
      return new DtVariableParameterNumberOrString(*this);
   }

   virtual void process(const std::string& parameter, luabind::object const& parameters)
   {
      luabind::object tableEntry = parameters[parameter];
      if (tableEntry.is_valid())
      {
         if (luabind::type(tableEntry) == LUA_TNUMBER)
         {
            myValue = DtString(luabind::object_cast<double>(tableEntry));
            mySpecified = true;
         }
         else if (luabind::type(tableEntry) != LUA_TNIL)
         {
            myValue = DtString(luabind::object_cast<std::string>(tableEntry).c_str());
            mySpecified = true;
         }
      }
   }
};

class DT_DLL_vrfLua DtVariableParameterBuilder 
{
private:

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

public:
   DtVariableParameterBuilder();

   virtual ~DtVariableParameterBuilder();

   void addVariableParameter(const std::string&, const DtVariableParameterInterface&);
   void removeVariableParameter(const std::string&);

   template <typename _Container> void addVariableParameter(const std::string& s)
   {
      addVariableParameter(s, DtVariableParameter<_Container>());
   }

   template <typename _Container> void addRequiredVariableParameter(const std::string& s)
   {
      addVariableParameter(s, DtVariableParameter<_Container>(true));
   }

   template <typename _Container> void addVariableParameterVector(const std::string& s)
   {
      addVariableParameter(s, DtVariableParameterVector<_Container>());
   }

   template <typename _Container> void addRequiredVariableParameterVector(const std::string& s)
   {
      addVariableParameter(s, DtVariableParameterVector<_Container>(true));
   }

   template <typename _Container> void addVariableParameterReaderWriter(const std::string& s)
   {
      addVariableParameter(s, DtVariableParameterReaderWriter<_Container>());
   }

   template <typename _Container> void addRequiredVariableParameterReaderWriter(const std::string& s)
   {
      addVariableParameter(s, DtVariableParameterReaderWriter<_Container>(true));
   }

   template <typename _Container> _Container value(const std::string& key) const
   {
      VariableParameters::const_iterator iter = myVariableParameters.find(key);

      if (iter != myVariableParameters.end())
      {
         return (dynamic_cast<DtVariableParameter<_Container>*>(iter->second)->value());
      }

      return _Container();
   }

   template <typename _Container> _Container* valuePointer(const std::string& key) const
   {
      VariableParameters::const_iterator iter = myVariableParameters.find(key);

      if (iter != myVariableParameters.end())
      {
         return (dynamic_cast<DtVariableParameter<_Container*>*>(iter->second)->value());
      }

      return 0;
   }

   template <typename _Container> void set(const std::string& key, const _Container& value)
   {
      VariableParameters::iterator iter = myVariableParameters.find(key);

      if (iter != myVariableParameters.end())
      {
         dynamic_cast<DtVariableParameter<_Container>*>(iter->second)->setValue(value);
      }
   }

   virtual bool valueIsSpecified(const std::string&) const;

   template <typename _Container>
   std::vector<_Container> valueToStdVector(const std::string& key) const
   {
      std::vector<_Container> results;
      luabind::object object = value<luabind::object>(key);

      if (luabind::type(object) == LUA_TTABLE)
      {
         for (luabind::iterator paramItr(object), end; paramItr != end; ++paramItr)
         {
            results.push_back(luabind::object_cast<_Container>(*paramItr));
         }
      }
      else if (luabind::type(object) == LUA_TSTRING)
      {
         results.push_back(luabind::object_cast<_Container>(object));
      }

      return results;
   }

   template <typename _Container>
   std::set<_Container> valueToStdSet(const std::string& key) const
   {
      std::set<_Container> results;
      luabind::object object = value<luabind::object>(key);

      if (luabind::type(object) == LUA_TTABLE)
      {
         for (luabind::iterator paramItr(object), end; paramItr != end; ++paramItr)
         {
            results.insert(luabind::object_cast<_Container>(*paramItr));
         }
      }
      else if (luabind::type(object) == LUA_TSTRING)
      {
         results.insert(luabind::object_cast<_Container>(object));
      }

      return results;
   }

   virtual void process(luabind::object const& parameters);

protected:
   typedef std::map<std::string, DtVariableParameterInterface*> VariableParameters;
   VariableParameters myVariableParameters;
};