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 <vlutil/vlString.h>
#include <luabind/luabind.hpp>
#include <stdexcept>

class DT_DLL_vrfLua DtVariableParameterInterface
{
public:
   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;
         }
      }
   }
};

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

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

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