StateInfoEncoder.hh

Go to the documentation of this file.

#ifndef __DIADES__SDMDL_EXPERIMENTAL__STATEINFOENCODER__HH__
#define __DIADES__SDMDL_EXPERIMENTAL__STATEINFOENCODER__HH__

#include<vector>
#include<diades/automata/experimental/StatePropertyManager.hh>
#include<diades/sdmdl/Variable.hh>
#include<diades/sdmdl/experimental/Assignment.hh>

namespace Diades
{
    namespace Sdmdl
    {
        namespace Experimental
        {
           

            class StateInfoEncoder
            {
            public:
                using VariableEncoderId = VariableVector::size_type;
                using StateInfoId = size_t; 
                
            private:
                VariableFactory & _variables;
                 
                VariableVector _encodedVariables;
                
                
                std::unordered_map<std::string,VariableEncoderId> _varDictionnary;
                
                
                std::vector<std::vector<StateInfoId> > _domains;

                
                std::vector< std::unordered_map<std::string,size_t> > _valueIndexes;
                
            public:

                StateInfoEncoder(VariableFactory & varFactory) :
                _variables(varFactory),
                _encodedVariables(),
                _varDictionnary(),
                        _domains(),
                        _valueIndexes()
                {
                }

                
            private:
                const Value & encodeStateInfoInVariable(VariableEncoderId varId,StateInfoId id)
                {
                   stringstream stream;
                    stream << id;
                    _domains[varId].push_back(id);
                    auto & value = _encodedVariables[varId].get().addValue(stream.str());
                    _valueIndexes[varId][stream.str()]=_domains[varId].size()-1;
                    return value;
                }
                               
            public:
                template<typename StateInfoIdIterator>
                VariableEncoderId
                    encodeStateInfoRange(StateInfoIdIterator first,
                                         StateInfoIdIterator last)
                { 
                    std::stringstream stream;
                    stream << "var_"
                            << this
                            << "_"
                            << _variables.numberOfAllocatedVariables();
                    VariableEncoderId result = _encodedVariables.size();
                    _encodedVariables.push_back(_variables.newVariable(stream.str()));
                    _varDictionnary[stream.str()]= result;
                    _domains.push_back(std::vector<StateInfoId>());
                    _valueIndexes.push_back(std::unordered_map<std::string,size_t>());
                    while (first != last)
                    {
                        encodeStateInfoInVariable(result,*first);
                        ++first;
                    }
                    return result;
                    
                }

                
                Variable & getVariable(VariableEncoderId id) const
                {
                    return _encodedVariables[id].get();
                }
                
                
                VariableEncoderId numberOfEncodedVariables() const
                {
                    return _encodedVariables.size();
                }
                
                VariableEncoderId getVariableId(const Variable & variable) const
                {
                    auto it = _varDictionnary.find(variable.name());
                    if(it==_varDictionnary.end())
                    {
                        return numberOfEncodedVariables();
                    }
                    if(variable!=getVariable(it->second))
                    {
                        return numberOfEncodedVariables();
                    }
                    return it->second;
                }
                
                
                
                std::vector<StateInfoId> & getDomain(VariableEncoderId id)
                {
                    return _domains[id];
                }
                
                
                std::pair<StateInfoId,bool> getStateInfoId(const Assignment & assignment) const
                {
                    std::pair<StateInfoId,bool> result= std::make_pair(0,true);
                    VariableEncoderId varId = getVariableId(assignment.variable());
                    if(varId==numberOfEncodedVariables())
                    {
                        result.second=false;     
                    }
                    else
                    {
                        auto it = _valueIndexes[varId].find(assignment.value().label());
                        result.second = (it != _valueIndexes[varId].end());
                        if(result.second)
                        {
                            result.first = _domains[varId][it->second];
                        }
                    }
                    return result;
                }
                    
                    
              
            };
        }
    }
}




#endif /* STATEINFOENCODER_HH */