src/engine/TemplateTable.h

Go to the documentation of this file.

#ifndef TEMPLATETABLE_H
#define TEMPLATETABLE_H

#include <boost/shared_ptr.hpp>
#include "KeyNameTable.h"
#include "Variable.h"
#include "VariableTableInstance.h"
#include "VariableTableTemplate.h"
                
namespace green
{
        typedef std::vector<Variable::Value> ArgList;
        typedef boost::shared_ptr<ArgList> ArgListPtr;
        
        //template<class templateType, class instanceType>
        class TemplateTable : 
                //public KeyNameTable<boost::shared_ptr<templateType> >
                public KeyNameTable<VariableTableTemplatePtr>
        {
        public:
                
                virtual ~TemplateTable() {}
                
                VariableTableInstancePtr Instantiate(Key key, ArgListPtr initArgs) const
                {
                        CHECK_SHARED(initArgs);
                        // Check the arguments and get the template entry
                        VariableTableTemplatePtr entry = 
                                        this->_checkInstArgs(key, initArgs);
                        
                        CHECK_SHARED(entry);
                        
                        // create a new instance with entry as its template
                        VariableTableInstancePtr instance(new VariableTableInstance(key));
                        this->_doInstantiate(instance, entry, initArgs);
                                
                        // and return the instance
                        return instance;
                        
                }
                
                void Print(std::ostream& os)
                {
                        for(Key i = 0; i < this->GetNumEntries(); i++)
                        {
                                _entryPtr curEntry(this->_getEntry(i));
                                os << "Template Key: " << i << " Name: " << curEntry->mName << std::endl;
                                os << "Template:" << std::endl;
                                curEntry->mValue->Print(os);
                                os << "---" << std::endl;
                        }
                }
                
                protected: 
                        
                        VariableTableTemplatePtr
                                _checkInstArgs(Key key, ArgListPtr initArgs) const
                        {
                                if(!this->HasEntry(key))
                                        THROW_ERROR("invalid key");
                        
                                VariableTableTemplatePtr entry(this->_getEntry(key)->mValue);
                
                                if(entry->GetInitFormat()->size() != initArgs->size())
                                        THROW_ERROR("initArgs is invalid size");
                                
                                return entry;
                        }
                        
                        void _doInstantiate(VariableTableInstancePtr instance, 
                                                                                                        VariableTableTemplatePtr templ, ArgListPtr args) const
                        {
                                // Now add the default values to the instance
                                for(Key i = 0; i < templ->GetNumEntries(); i++)
                                        instance->AddVariable(templ->GetEntry(i).mDefaultValue);
                        
                                // Now set the initializers
                                for(size_t i = 0; i < args->size(); i++)
                                        instance->SetVariable(templ->GetInitFormat()->at(i).mKey, (*args)[i]);
                        }
        };
        typedef boost::shared_ptr<TemplateTable> TemplateTablePtr;
        #define TEMPLATE_TABLE_CAST(x) boost::dynamic_pointer_cast<TemplateTable>(x)
}
 #endif

---