EventEncoder.hh

Go to the documentation of this file.

#ifndef __DIADES__SDMDL_EXPERIMENTAL__EVENTENCODER__HH__
#define __DIADES__SDMDL_EXPERIMENTAL__EVENTENCODER__HH__

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

namespace Diades
{
    namespace Sdmdl
    {
        namespace Experimental
        {
           

            class EventEncoder
            {
            public:
                using VariableEncoderId = VariableVector::size_type;
                using Event = size_t;
                
                
            private:
                VariableFactory & _variables;
                
                VariableVector _encodedVariables;
                
                std::vector<std::vector<Event> > _domains;

            public:

                EventEncoder(VariableFactory & varFactory):
                _variables(varFactory),
                _encodedVariables(),
                _domains()
                {}

            private:                
                const Value & encodeEventInVariable(VariableEncoderId varId,Event evt)
                {
                    stringstream stream;
                    stream << evt;
                    _domains[varId].push_back(evt);
                    return _encodedVariables[varId].get().addValue(stream.str());
                }
                               
                
            public:
                template<typename EventIterator>
                VariableEncoderId
                    encodeEventRange(EventIterator first,
                                         EventIterator last)
                { 
                    std::stringstream stream;
                    stream << "var_"
                            << this
                            << "_"
                            << _variables.numberOfAllocatedVariables();
                    VariableEncoderId result = _encodedVariables.size();
                    _encodedVariables.push_back(_variables.newVariable(stream.str()));
                    _domains.push_back(std::vector<Event>());
                    while (first != last)
                    {
                        encodeEventInVariable(result,*first);
                        ++first;
                    }
                    return result;
                    
                }

              
                Variable & getVariable(VariableEncoderId id)
                {
                    return _encodedVariables[id].get();
                }
                
                std::vector<Event> & getDomain(VariableEncoderId id)
                {
                    return _domains[id];
                }
                
            };
        }
    }
}




#endif