Oracle_learn.hpp

Go to the documentation of this file.

/*-------------------------------------
 * Oracle_learn.hpp
 * Created on 17/03/09 by BenCello
 *-------------------------------------*/


#ifndef __ORACLE_LEARN_HPP__
#define __ORACLE_LEARN_HPP__

#include <vector>
using namespace std;

#include "Oracle_classes.hpp"
#include "Oracle_data.hpp"
#include "Oracle_label.hpp"

// Prototypes //

class O_learner
{
protected:
        O_oracle * oracle;
        O_data * data;
public:


        O_learner();
        O_learner(O_oracle &, O_data &);
        ~O_learner(){};
        


        O_oracle * get_oracle();
        void set_oracle(O_oracle &);
        O_data * get_data();
        void set_data(O_data &);
        


        template<class O_DataType>
        int add(O_DataType &);
        int lrs(O_state &, O_state &);
        template<class O_DataType>
        int search_trans(O_state &, O_DataType &);
};

// Functions //

O_learner::O_learner()
{
        oracle = NULL;
        data = NULL;
}

O_learner::O_learner(O_oracle & oraclin, O_data & datain)
{
        oracle = &oraclin;
        data = &datain;
}

O_oracle * O_learner::get_oracle()
{
        return oracle;
}

void O_learner::set_oracle(O_oracle & oraclin)
{
        oracle = &oraclin;
}

O_data * O_learner::get_data()
{
        return data;
}

void O_learner::set_data(O_data & dataIn)
{
        data = &dataIn;
}

// build
template<class O_DataType>
int O_learner::add(O_DataType & dataIn)
{
        // initialisation if needed
        if (oracle->state_vect.size()<1)
        {
                oracle->start();
                data->start<O_DataType>();
        }
        
        int j,k,l;
        int newstatenb;
        
        O_state * O_it = oracle->state_vect.back(); // old last
        newstatenb = O_it->get_statenb()+1; // new number
        
        // create new data
        O_DataType * newdata = new O_DataType(dataIn);
        ((O_label*)newdata)->set_statenb(newstatenb);
        data->state_vect.push_back((O_label*)newdata); // add
        data->size = data->state_vect.size(); // update size
        data->add_state(*newdata); // add state to hashtable
        data->add_date(*newdata); // add date to hashtable
        
        // create new state
        O_state * newstate = new O_state(newstatenb);
        oracle->state_vect.push_back(newstate); // add
        oracle->size = oracle->state_vect.size(); // update size
        
        // basic transition
        O_it->add_trans(newstate);
        
        // suffix algorithm
        j = O_it->get_statenb();
        if(O_it->get_suffix().first)
                k = O_it->get_suffix().first->get_statenb();
        else
                k = -1;
        while (k>=0 && search_trans(*oracle->state_vect[k], *newdata)==-1)
        {
                oracle->state_vect[k]->add_trans(newstate);
                j = k;
                if(oracle->state_vect[k]->get_suffix().first)
                        k = oracle->state_vect[k]->get_suffix().first->get_statenb();
                else
                        k = -1;
        }
        if (k==-1)
                l = 0;
        else
                l = search_trans(*oracle->state_vect[k], *newdata);

        int lrsnew = lrs(*(*oracle)[j],*(*oracle)[l]); // lrs
        oracle->state_vect.back()->set_suffix((*oracle)[l],lrsnew);
        
        // reversed suffix
        pair<O_state*,int> * rsuff = new pair<O_state*,int>(newstate,lrsnew);
        oracle->state_vect[l]->add_rsuff(*rsuff);
        
        return (newstatenb);
}

template<class O_DataType>
int O_learner::search_trans(O_state & statein, O_DataType & dataIn)
{
        int intout = -1;
        bool found = false;
        list<O_state*> thistrans = statein.get_trans();
        list<O_state*>::iterator transit;
        for (transit = thistrans.begin(); (!found) && (transit != thistrans.end()); transit++)
        {
                if ((*(O_DataType*)(*data)[(*transit)->get_statenb()]) == dataIn)
                {
                        intout = (*transit)->get_statenb();
                        found = true;
                }
        }
        return intout;
}

int O_learner::lrs(O_state & state1, O_state & state2)
{
        if(state2.get_statenb() == 0)
                return 0;
        else
        {
                O_state * pi2 = (*oracle)[state2.get_statenb()-1];
                if (pi2->get_statenb() == state1.get_suffix().first->get_statenb())
                        return(state1.get_suffix().second + 1);
                else
                {
                        while (pi2->get_suffix().first != state1.get_suffix().first)
                                pi2 = pi2->get_suffix().first;
                        if (state1.get_suffix().second> pi2->get_suffix().second)
                                return(pi2->get_suffix().second + 1);
                        else
                                return(state1.get_suffix().second + 1);
                }
        }
}

#endif