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<diades/utils/Exceptions.hh>
#include<diades/utils/Assertion.hh>

#include<diades/altarica/Type.hh>


using namespace std;

namespace Diades
{
  namespace Altarica
  {
        using Diades::Utils::Msg;
        
  
  
        class Value;
        class ValueFactory;
        class AltaricaModel;
        class AltaricaModelData;
          
        class Value
        {
        public:

          typedef enum{OrOp=0,AndOp=1,ImplyOp=2,EqOp=3,NeqOp=4,GtOp=5,GeqOp=6,LtOp=7,LeqOp=8,AddOp=9,SubOp=10,MulOp=11,DivOp=12,ModOp=13} BinaryOperator;
          typedef enum{NotOp,NegOp,IdentityOp} UnaryOperator;

          
          typedef vector<int>::size_type Code; 
          typedef reference_wrapper<Value> Reference;
          typedef reference_wrapper<Value const> ConstReference;
          typedef Value * Pointer;
          typedef map<Identifier,ConstReference> StructureFields;

          typedef vector<ConstReference> ArrayFields; 



          
        public:
          typedef Utils::Exception<Value> Exception;
          static string typeName() { return "Altarica::Value"; }
        
        private:
          ValueFactory & _factory;
          Type::ConstReference _type;
          Code _code;
          bool _boolean;
          int  _integer;
          Identifier _identifier;
          StructureFields _structure;
          ArrayFields _array;


          Value(ValueFactory & factory);
          bool isEqualStructure(const Value & value) const;
          bool isLessStructure(const Value & value) const;
          bool isEqualArray(const Value & value) const;
          bool isLessArray(const Value & value) const;

          friend class ValueFactory;
        public:
         
          bool isNull() const;
          int  integer() const
          {
                always_require(Exception, !isNull(),"integer(): invalid value");
                always_require(Exception, type().isInteger(), "integer(): this value is not an integer");
                return _integer;
          }
          bool  boolean() const
          {
                always_require(Exception, !isNull(),"boolean(): invalid value");
                always_require(Exception, type().isBoolean(), "boolean(): this value is not a boolean");
                return _boolean;
          }

          const Identifier & identifier() const 
          {
                always_require(Exception, !isNull(),"identifier(): invalid value");
                always_require(Exception, type().isIdentifier(), "identifier(): this value is not an indentifier");
                return _identifier;
          }

          unsigned size() const;

          const Value & getField(unsigned index) const;


          const Value & getField(const Identifier & fieldName) const;
        
          const Type & type() const 
          {
                        return _type;
          }

          Code code() const 
          {
                always_require(Exception,!isNull(),"code(): invalid value");
                return _code;
          }

          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(BinaryOperator op, const Value & value) const;

          const AltaricaModel & owner() const;


          const Value & apply(BinaryOperator op, const Value & value) const;
          const Value & apply(UnaryOperator op) const;

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

        typedef vector<Value::ConstReference> ValueEnumeration; 


        template<typename T>
        struct EqualRef
        {
          bool operator()(const reference_wrapper<T> & ref1, const reference_wrapper<T> & ref2)
          {
                return ref1.get() == ref2.get();
          }
        };




        template<typename T>
        bool isEqual(const vector< reference_wrapper<T> > & vect1, const vector< reference_wrapper<T> > & vect2)
        {
          bool result  = vect1.size() == vect2.size();
          unsigned index = 0;
          while(result && (index < vect1.size()))
                {
                  result = EqualRef<T>()(vect1[index],vect2[index]);
                  ++index;
                }
          return result;
        }

        template<typename T1, typename T2>
        bool isEqual(const map< T1, reference_wrapper<T2> > & map1, const map< T1, reference_wrapper<T2> > & map2)
        {
          bool result  = map1.size() == map2.size();
          typename map< T1, reference_wrapper<T2> >::const_iterator it1 = map1.begin();
          typename map< T1, reference_wrapper<T2> >::const_iterator it2 = map2.begin();
          while(result && (it1 != map1.end()))
                {
                  result = (it1->first == it2->first) && EqualRef<T2>()(it1->second,it2->second);
                  ++it1;++it2;
                }
          return result;
        }


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

        class ValueFactory
        {
        public:
          typedef Utils::Exception<ValueFactory> Exception;
          static string typeName() { return "Diades::Altarica::ValueFactory"; }
        
        public:
        
          const Value & getValue(const Identifier & value);
          const Value & getValue(bool value);
          const Value & getValue(int value);
          
          const Value &  getValue(const Value::ArrayFields & arrayValueFields);

          const Value & getValue(const Value::StructureFields & structureValueFields);



          const Value & nullValue() const
          {
                return *_basicValues[0];
          }


          ~ValueFactory();

         

          ValueFactory(AltaricaModel & model);

          void init();

          void clear();

          const AltaricaModel & owner() const;
          AltaricaModel & owner();
        private:
          AltaricaModel & _owner;
          vector<Value::Pointer> _basicValues;
          unordered_map<Identifier,unsigned> _identifierMapping;
          unordered_map<int,Value::Pointer> _integerMapping;
          vector<Value::Pointer> _identifierValues;
          unordered_map<string,unsigned> _structureMapping;
          vector<Value::Pointer> _structuredValues;
          unordered_map<string,unsigned> _arrayMapping;
          vector<Value::Pointer> _arrayedValues;
         
        
          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();
          }
        };


        template <Value::BinaryOperator OP>
        struct BinaryOperator
        {
          typedef Utils::Exception< BinaryOperator<OP> > Exception;
          static string typeName() { return "Diades::Altarica::BinaryOperator"; }
          const Value & operator() (const Value & value1, const Value & value2) const
          {
                try
                  {
                        return value1.apply(OP,value2);
                  }
                catch(exception & e)
                  {
                        throw(Exception(Msg("Failure to apply a binary operator between '%1%' and '%2%'.")
                                                        % value1 % value2,e));
                  }
                return value1;
          }
        };

        template <Value::UnaryOperator OP>
        struct UnaryOperator
        {
          typedef Utils::Exception< UnaryOperator<OP> > Exception;
          static string typeName() { return "Diades::Altarica::UnaryOperator"; }
          const Value & operator() (const Value & value) const
          {
                try
                  {
                        return value.apply(OP);
                  }
                catch(exception & e)
                  {
                        throw(Exception(Msg("Failure to apply a unary operator on value '%1%'.")
                                                        % value,e));
                  }
                return value;
          }
        };

        




        
  };
};








#endif