Assignment.hh

Go to the documentation of this file.

#ifndef _DIADES__SDMDL_EXPERIMENTAL__ASSIGNMENT__HH__
#define _DIADES__SDMDL_EXPERIMENTAL__ASSIGNMENT__HH__

#include<diades/sdmdl/Variable.hh>

namespace Diades
{
    namespace Sdmdl
    {
        namespace Experimental
        {
            
            class Assignment
            {
            public:
                using Variable  = Diades::Sdmdl::Variable;
                
                using Value = Diades::Sdmdl::Value;
                
                using Exception = Diades::Utils::Exception<Assignment>;

                static string typeName()
                {
                    return "Sdmdl::Experimental::Assignment";
                }

            private: 
                using ConstVarReference =  std::reference_wrapper<Variable const>;
                using ConstValReference =  std::reference_wrapper<Value const>;
                using VarVector = std::vector<ConstVarReference>;
                using ValVector = std::vector<ConstValReference>;
                VarVector _variable;
                ValVector _value;


            public:

                Assignment() : _variable(), _value()
                {
                }

                bool valid() const
                {
                    return (_variable.size()==1)  && (_value.size()==1)
                            && (!_variable[0].get().isNull()) && (!_value[0].get().isNull()) 
                            && (_variable[0].get().contains(_value[0].get()));
                }

                Assignment(const Variable & var, const Value & val): _variable(), _value()
                {
                    _variable.push_back(var);
                    _value.push_back(val);
                }

                Assignment(const Assignment & assignment) : _variable(), _value()
                {
                       if(assignment._variable.size()==1)
                    {
                        _variable.emplace_back(assignment.variable());
                    }
                    if(assignment._value.size()==1)
                    {
                        _value.emplace_back(assignment.value());
                    }
                }
                
                Assignment(const Assignment && assignment) : _variable(), _value()
                {
                    if(assignment._variable.size()==1)
                    {
                        _variable.emplace_back(assignment.variable());
                    }
                    if(assignment._value.size()==1)
                    {
                        _value.emplace_back(assignment.value());
                    }
                }
                
                
                virtual ~Assignment()
                {
                }

                void setVariable(const Variable & var)
                {
                    _variable.clear();
                    _value.clear();
                    if(!var.isNull())
                    {
                        if(!var.defaultValue().isNull())
                        {
                            _variable.push_back(var);
                            _value.push_back(var.defaultValue());
                        }
                    }
                }


                void setValue(const Value & val)
                {
                    if((_variable.size()==1) && (!_variable[0].get().isNull()))
                    {
                        if(!val.isNull() && _variable[0].get().contains(val))
                        {
                            _value.clear();
                            _value.push_back(val);
                        }
                    }
                }
                        

                const Variable & variable() const
                {
                    require(Exception,valid(),"variable(): invalid assignment");
                    return _variable[0].get();
                }

                const Value & value() const
                {
                    require(Exception,valid(),"value(): invalid assignment");
                    return _value[0].get();
                }

                Assignment & operator=(const Assignment & assign)
                {
                    if (&assign != this)
                    {
                        _variable.clear();
                        if(assign._variable.size() == 1)
                        {
                            _variable.push_back(assign.variable());
                        }
                        _value.clear();
                        if(assign._value.size()==1)
                        {
                            _value.push_back(assign.value());
                        }
                    }
                    return *this;
                }

                bool operator==(const Assignment & assignment) const
                {
                    return (!valid() && !assignment.valid())
                            || (valid() && assignment.valid() && (variable() == assignment.variable()) && (value() == assignment.value()));
                }


                void unvalidate()
                {
                    _variable.clear();
                    _value.clear();
                }


                friend ostream & operator<<(ostream & os, const Assignment & assign)
                {
                    if(assign.valid())
                    {
                        os << assign.variable() << "=" << assign.value();
                    }
                    else
                    {
                        os << "INVALID_ASSIGNMENT";
                    }
                    return os;
                }

            };
        }
    }
}

#endif