Value.hh

Go to the documentation of this file.

#ifndef  __DIADES__ALTARICA__VALUE__HH
#define  __DIADES__ALTARICA__VALUE__HH

#include<string>
#include<unordered_map>
#include<limits>
#include<vector>
#include<set>
#include<utils/Exceptions.hh>
#include<utils/Assertion.hh>

#include"Type.hh"


using namespace std;

namespace Diades
{
  namespace Altarica
  {
  
        typedef vector<int>::size_type ValueCode; 
  
  
        class Value;
        class ValueFactory;

        typedef enum{Eq,Neq,Gt,Geq,Lt,Leq} ConstraintOperator;

        typedef map<Identifier,Value> StructureValueFields;


        typedef vector<Value> ArrayValueFields; 
  
        class ValueData
        {
        private:
          Type _type;
          ValueCode _code;
          union 
          {
                bool _boolean;
                int  _integer;
                Identifier * _identifierPointer;
                StructureValueFields * _structurePointer;
                ArrayValueFields * _arrayPointer;
          } _value;
          ValueData():_type(),_code(0),_value() { _value._boolean = false; }
          ~ValueData();
          
          friend class ValueFactory;
          friend class Value;
          friend ostream & operator<<(ostream & os, const Value & value);
        };


  

  
        class Value
        {
        public:
          typedef Utils::Exception<Value> Exception;
          static string typeName() { return "Altarica::Value"; }
        
        private:
          ValueData * _data;
          Value(ValueData * data):_data(data){}
          bool isEqualStructure(const Value & value) const;
          bool isLessStructure(const Value & value) const;
          bool isEqualArray(const Value & value) const;
          bool isLessArray(const Value & value) const;

          
        public:
          Value():_data(0){}

          Value(const ArrayValueFields & arrayValueFields);
          Value(const StructureValueFields  & structureValueFields);
          Value(const Value & value):_data(value._data){}
          Value & operator=(const Value & value) {
                if(this != &value)
                  {
                        _data = value._data;
                  }
                return *this;
          }
          bool valid() const {
                return _data!=0 && _data->_type.valid()
                  && (!_data->_type.isIdentifier() || _data->_value._identifierPointer != 0)
                  && (!_data->_type.isArray() || _data->_value._arrayPointer != 0)
                  && (!_data->_type.isStructure() || _data->_value._structurePointer != 0);
          }
          int  integer() const 
          {
                require(Exception, valid(),"integer(): invalid value");
                require(Exception, type().isInteger(), "integer(): this value is not an integer");
                if(valid() && type().isInteger())
                  {
                        return _data->_value._integer;
                  }
                return 0;
          }
          bool  boolean() const 
          {
                require(Exception, valid(),"boolean(): invalid value");
                require(Exception, type().isBoolean(), "boolean(): this value is not a boolean");
                if(valid() && type().isBoolean())
                  {
                        return _data->_value._boolean;
                  }
                return false;
          }

          Identifier identifier() const 
          {
                require(Exception, valid(),"identifier(): invalid value");
                require(Exception, type().isIdentifier(), "identifier(): this value is not an indentifier");
                if(valid() && type().isIdentifier())
                  {
                        return *(_data->_value._identifierPointer);
                  }
                return "";
          }

          unsigned size() const;

          Value getField(unsigned index) const;


          Value getField(const Identifier & fieldName) const;
        
          Type type() const 
          {
                if(valid())
                  {
                        return _data->_type;
                  }
                return Type();
          }

          int code() const 
          {
                require(Exception,valid(),"code(): invalid value");
                if(valid())
                  {
                        return _data->_code;
                  }
                return -1;
          }

          string textify() const;

          bool operator==(const Value & value) const;

          bool operator!=(const Value & value) const { return !(*this == value); }
          bool operator<(const Value & value) const;
          bool operator>(const Value & value) const { return (value < *this); }
          bool operator<=(const Value & value) const { return  (*this < value) || (*this == value); }
          bool operator>=(const Value & value) const { return  (*this > value) || (*this == value); }

          bool constraint(ConstraintOperator op, const Value & value) const
          {
                switch(op)
                  {
                  case Eq:
                        {
                          return (*this) == value;
                        }
                        
                  case Neq:
                        {
                          return (*this) != value;
                        }
                  case Gt:
                        {
                          return (*this) > value;
                        }
                  case Geq:
                        {
                          return (*this) >= value;
                        }
                  case Lt:
                        {
                          return (*this) < value;
                        }
                  case Leq:
                        {
                          return (*this) <= value;
                        }
                  default:
                        {}
                  }
                return false;
          }

          
          friend ostream & operator<<(ostream & os, const Value & value);
          friend class ValueFactory;
        };

        typedef set<Value> ValueSet; 
        
        /****************************************************************************/

        class ValueFactory
        {
        public:
          typedef Utils::Exception<ValueFactory> Exception;
          static string typeName() { return "Altarica::ValueFactory"; }
        
        public:
          static ValueFactory * factory();
          Value getValue(const Identifier & value);
          Value getValue(bool value);
          Value getValue(int value);
          Value getValue(const ArrayValueFields & arrayValueFields);
          Value getValue(const StructureValueFields & structureValueFields);
          ~ValueFactory();
          
        private:
          static ValueFactory * _valueFactory;
          ValueData * _isTrue;
          ValueData * _isFalse;
          unordered_map<Identifier,Value> _identifierMapping;
          unordered_map<int,Value> _integerMapping;
          vector<Value> _identifierValues;
          vector<Value> _structuredValues;
          vector<Value> _arrayedValues;
          ValueFactory();
        
          friend class AltaricaModel;
          friend class Value;
        };

        /****************************************************************************/

        struct GetValueIdentifier
        {
          Identifier  operator()(const Value & value)
          {
                return value.identifier();
          }
        };


        struct GetValueInteger
        {
          int  operator()(const Value & value)
          {
                return value.integer();
          }
        };

        struct GetValueBoolean
        {
          bool operator()(const Value & value)
          {
                return value.boolean();
          }
        };


        Value getValue(const Identifier & value);

        
        Value getValue(bool value);
        Value getValue(int value);
        Value getValue(const ArrayValueFields & arrayValueFields);
        Value getValue(const StructureValueFields & structureValueFields);





        
  };
};








#endif