Variable.hh

Go to the documentation of this file.

#ifndef __DIADES__SDMDL__VARIABLE__HH
#define __DIADES__SDMDL__VARIABLE__HH

#include<vector>
#include<ostream>
#include<diades/utils/Exceptions.hh>
#include<diades/sdmdl/Value.hh>


namespace Diades
{
  namespace Sdmdl
  {

        class VariableFactory;
        
        class Variable
        {
        public:
          typedef Utils::Exception<Variable> Exception;
          static string typeName() { return "Diades::Sdmdl::Variable"; }

        public:
          typedef std::reference_wrapper<Variable const> ConstReference;
          typedef std::reference_wrapper<Variable> Reference;
          typedef std::vector<Reference> VariableVector;
          typedef Variable * Pointer;

        private:
          string  _name;

          unsigned _id;


          unsigned _index;
          
          

          VariableFactory & _owner;

          ValueFactory  _values;
          

          
          ValueVector _domain;

          ValueVector  _default;

          ValueVector  _current;
          
          bool _observable;     


        private:

      Variable(VariableFactory & owner):_name("__null__diades__sdmdl_variable"),_id(0),_index(0),_owner(owner),_values(),_domain(),_default(),_current(),_observable(false) {}


          Variable(const string & name, unsigned id, VariableFactory & owner):_name(name),_id(id),_index(0),_owner(owner),_values(),_domain(),_default(),_current(),_observable(false){}



        public:

          ~Variable(){}

          

          const string & name() const
          {
                return _name;
          }


          unsigned id() const
          {
                return _id;
          }
                

          const VariableFactory & owner() const
          {
                return _owner;
          }
          
          VariableFactory & owner()
          {
                return _owner;
          }


          bool isNull() const;


          bool operator==(const Variable & variable) const
          {
                return this == &variable;
          }



          bool operator!=(const Variable & variable) const
          {
                return !(*this == variable);
          }



          const ValueVector & domain() const
          {
                return _domain;
          }




          void setIndex(unsigned index)
          {
                _index = index;
          }

          unsigned index() const
          {
                return _index;
          }


          const Value & addValue(const string & label);


          bool containsValueOfLabel(const string & label) const;


          bool contains(const Value & val) const;

          
          
          void setDefault(const Value & val)
          {
                require(Exception,!val.isNull(),"setDefault: the Value is null");
                require(Exception,contains(val),
                                Utils::Msg("setDefault: the Value %1% does not belong to the domain of the Variable %2%")
                                % val % name());
                _default.clear();
                _default.push_back(val);
          }
                

                


          void setObservable()
          { 
                require(Exception,!isNull(),"setObservable, null variable");
                _observable = true;
          }



          void setUnObservable()
          { 
                require(Exception,!isNull(),"setObservable, null variable");
                _observable = false;
          }




          bool isObservable() const
          {
                return _observable;
          }


          const Value & getValue(const string & label) const;
          
          const Value & getValue(unsigned id) const;
          
          const Value & defaultValue() const;


          const Value & value() const;

          void assign(const Value & value)
          {
                require(Exception,contains(value),
                                Utils::Msg("assign: the Value %1% is not contained in the Variable %2%")
                                % value % name());
                _current.clear();
                _current.push_back(value);
          }




          friend ostream & operator<<(ostream & os, const Variable & variable);


          friend class VariableFactory;
          
        };



        typedef Variable::VariableVector VariableVector;



        class VariableFactory
        {

        public:
          static std::string typeName() { return "Diades::Sdmdl::VariableFactory"; }
          typedef Diades::Utils::Exception<VariableFactory> Exception;


        private:
          std::unordered_map<std::string,Variable::Pointer> _dictionary;

          VariableVector _nullVariable;



        public:

          VariableFactory():_dictionary(),_nullVariable()
          {
                reset();
          }



          ~VariableFactory()
          {
                clear();
          }


          void reset();

          
          void clear();
          

          bool operator==(const VariableFactory & factory) const
          {
                return this == &factory;
          }

          size_t numberOfAllocatedVariables() const
          {
              return _dictionary.size();
          }
          
          Variable & newVariable(const std::string & label);

          Variable & getVariable(const std::string & label);

          const Variable & nullVariable() const
          {
                return _nullVariable[0];
          }


          Variable & nullVariable() 
          {
                return _nullVariable[0];
          }

        };
        


        
  };
};

#endif