src/engine/Variable.h

Go to the documentation of this file.

#ifndef VARIABLE_H
#define VARIABLE_H

#include <iostream>
#include <boost/shared_ptr.hpp>

namespace green
{

        class Variable
        {
        public:
                enum Type {FLOAT_VAR, INT_VAR};
                
                union Value {
                        Value() : intVal(0) {}
                        Value(int ival) : intVal(ival) {}
                        Value(float fval) : floatVal(fval) {}
                        int intVal; 
                        float floatVal; 
                };
                
                Variable() : mType(INT_VAR) {mValue.intVal = 0;}
                
                Variable(int copy) {
                        mType = INT_VAR;
                        mValue.intVal = copy;
                }
                
                Variable(float copy) {
                        mType = FLOAT_VAR;
                        mValue.floatVal = copy;
                }

                bool operator==(const Variable& rhs) const
                {
                        bool ret = false;
                        if(rhs.mType == mType)
                        {
                                switch(mType)
                                {
                                        case INT_VAR:
                                                if(mValue.intVal == rhs.mValue.intVal)
                                                        ret = true;
                                                break;
                                        case FLOAT_VAR:
                                                if(mValue.floatVal == rhs.mValue.floatVal)
                                                        ret = true;
                                                break;
                                }
                        }
                        return ret;
                }
                
                Variable& operator=(int value)
                {
                        mType = INT_VAR;
                        mValue.intVal = value;
                        return *this;
                }
                
                Variable& operator=(float value)
                {
                        mType = FLOAT_VAR;
                        mValue.floatVal = value;
                        return *this;
                }

                void Print(std::ostream& os) const
                {
//                      os << "Type: ";
//                      switch(mType)
//                      {
//                              case INT_VAR:
//                                      os << "INT_VAR VALUE: " << mValue.intVal;
//                                      break;
//                              case FLOAT_VAR:
//                                      os << "FLOAT_VAR VALUE: " << mValue.floatVal;
//                                      break;
//                      }                       
                }
                
                virtual ~Variable() {}

                inline Variable::Type GetType() const { return mType; }

                inline void SetType(Variable::Type type) { mType = type; }

                inline Variable::Value GetValue() const { return mValue; }

                inline void SetValue(Variable::Value value) {mValue = value; }
                
                 inline void SetValue(int value) { *this = value; }
                 
                 inline void SetValue(float value) { *this = value; }
                 
        private:
                Variable::Value mValue; 
                Variable::Type mType; 
        };
        typedef boost::shared_ptr<Variable> VariablePtr;
        
        inline
        std::ostream& operator<<(std::ostream& lhs, const Variable& rhs)
        {
                rhs.Print(lhs);
                return lhs;
        }
        
        inline
        std::ostream& operator<<(std::ostream& lhs, const Variable::Type& rhs)
        {
                switch(rhs)
                {
                        case Variable::INT_VAR:
                                lhs << "INT_VAR";
                                break;
                        case Variable::FLOAT_VAR:
                                lhs << "FLOAT_VAR";
                                break;
                        default:
                                lhs << "Unknown Variable::Type";
                                break;
                }
                lhs << std::flush;
                return lhs;
        }

        inline
                        std::ostream& operator<<(std::ostream& lhs, const Variable::Value& rhs)
        {
                lhs << "(" << rhs.intVal << ", " << rhs.floatVal << ")" << std::flush;
                return lhs;
        }
        
        inline
        void PrintValue(const Variable::Value& value, Variable::Type type, std::ostream& os)
        {
                switch(type)
                {
                        case Variable::INT_VAR:
                                os << value.intVal;
                                break;
                        case Variable::FLOAT_VAR:
                                os << value.floatVal;
                                break;
                        default:
                                os << "unknown Variable::Type" << std::endl;
                                break;
                }
        }
}
#endif

---