src/engine/VariableTableTemplate.h

Go to the documentation of this file.

#ifndef VARIABLETABLETEMPLATE_H_
#define VARIABLETABLETEMPLATE_H_

#include <iostream>
#include <string>
#include <vector>
#include <map>
#include <boost/shared_ptr.hpp>
#include "Variable.h"
#include "KeyNameTable.h"

namespace green
{
        class VariableEntry
        {
        public:
                VariableEntry(Variable::Type type, Variable::Value defaultValue) :
                        mType(type), mDefaultValue(defaultValue) {}
                
                VariableEntry() : mType(Variable::INT_VAR), mDefaultValue(0) {}
                Variable::Type mType;
                Variable::Value mDefaultValue;
        };
        
        class InitArgFormat
        {
                public:
                        InitArgFormat(  Key key, Variable::Type type) :
                                mKey(key),
                                                 mType(type)
                                                 {}
                        Key mKey;                       
                        Variable::Type mType;
        };
        typedef boost::shared_ptr<InitArgFormat> InitArgFormatPtr;
        typedef std::vector<InitArgFormat> InitFormat;
        typedef boost::shared_ptr<InitFormat> InitFormatPtr;
        
                
        class VariableTableTemplate : public KeyNameTable<VariableEntry>
        {
        public:
                
                VariableTableTemplate() :
                        KeyNameTable<VariableEntry>(),
                        mInitFormat(new InitFormat())
                {}
                        
                virtual ~VariableTableTemplate() {}
                
                inline
                InitFormatPtr GetInitFormat() const {
                        return mInitFormat;
                }
                
                 void SetInitFormat(InitFormatPtr format)
                 {
                         CHECK_SHARED(format);
/*                       for(size_t i = 0; i < format->size(); i++)
                         {
                                if(!this->HasEntry(format->at(i).mKey))
                                         THROW_ERROR("argument key is not in table");
                         }
*/                       mInitFormat = format;
                 }
                 
                Key AddEntry(const Name& name, Variable::Type type, Variable::Value value)
                {
                        VariableEntry f;
                        f.mType = type;
                        f.mDefaultValue = value;
                        return KeyNameTable<VariableEntry>::AddEntry(name, f); 
                }

                virtual
                void Print(std::ostream& os)
                {
                        os << "InitFormat: ";
                        for(size_t i = 0; i < mInitFormat->size(); i++) {
                                os << "[Key: " << mInitFormat->at(i).mKey;
                                os << " Type: " << mInitFormat->at(i).mType << "] ";
                        }
                        os << std::endl;
                        for(Key i = 0; i < this->GetNumEntries(); i++)
                        {
                                _entryPtr curEntry(this->_getEntry(i));
                                os << " Variable Key: " << i << " Name: " << curEntry->mName;
                                os << " Type: " << curEntry->mValue.mType;
                                os << " Default Value: " << curEntry->mValue.mDefaultValue << std::endl;
                        }
                                
                }
                        
        protected:
        
                InitFormatPtr mInitFormat;
                  
        };
        typedef boost::shared_ptr<VariableTableTemplate> VariableTableTemplatePtr;
        #define VARIABLE_TABLE_TEMPLATE_CAST(x) boost::dynamic_pointer_cast<VariableTableTemplate>(x)
}

#endif /*VARIABLETABLETEMPLATE_H_*/

---