Value.hh

Go to the documentation of this file.

#ifndef __DIADES__SDMDL__VALUE__HH
#define __DIADES__SDMDL__VALUE__HH

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


namespace Diades
{
  namespace Sdmdl
  {


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

        public:
          typedef std::reference_wrapper<Value const> ConstReference;
          typedef std::reference_wrapper<Value> Reference;
          typedef std::vector<ConstReference> ValueVector;
          typedef Value * Pointer;


        private:
          
          unsigned _id;

         
          ValueFactory & _owner;



          std::string _label;

        private:

          Value(ValueFactory & owner):_id(0),_owner(owner),_label("__null__diades__sdmdl_value"){}



          Value(const std::string & label, unsigned id, ValueFactory & owner):_id(id),_owner(owner),
                                                                                                                                         _label(label){}


        public:

          ~Value(){}

          bool isNull() const;
          
          unsigned id() const
          {
                return _id;
          }

          const std::string & label() const
          {
                return _label;
          }


          
          bool operator == (const Value & val) const
          {  return this == &val; }

          
          bool operator != (const Value & val) const {  return !(*this == val); }

          
          bool operator < (const Value & val) const
          {
                require(Exception,&_owner == &val._owner,"operator<: not the same owner");
                return label() < val.label();
          }


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


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


          
          friend class ValueFactory;
        };


        typedef Value::ValueVector ValueVector;

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


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

          

          ValueVector _nullValue;



        public:

          ValueFactory():_dictionary(),_nullValue()
          {
                reset();
          }



          ~ValueFactory()
          {
                clear();
          }


          void reset();

          
          void clear();
          

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

          
          const Value & newValue(const std::string & label);

          const Value & getValue(const std::string & label) const;

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

        };



        
        
  };
};




#endif