Oracle_data.hpp

Go to the documentation of this file.

/*-------------------------------------
 * Oracle_data.hpp
 * Created on 20/03/09 by BenCello
 *-------------------------------------*/


#ifndef __ORACLE_DATA_HPP__
#define __ORACLE_DATA_HPP__

#include <vector>
#include <map>
using namespace std;

#include "Oracle_label.hpp"


// Prototypes //

class O_data
{
protected:
        int size;


        map<int,int> * dates2states;
        map<int,int> * states2dates;

        vector<O_label *> state_vect;
public:


        O_data();
        O_data(const O_data &);
        ~O_data();
        


        template<class O_DataType>
        void start();
        template<class O_DataType>
        void freestates();
        void clear_vect();
        


        template<class O_DataType>
        int add(int, O_label*);
        int get_size();
        


        void add_date(O_label &);
        void add_date(int,int);
        int get_state(int);
        void reset_D2S();
        


        void add_state(O_label &);
        void add_state(int,int);
        int get_date(int);
        void reset_S2D();
        


        O_label* operator[] (int) const;
        
        // friends
        friend class O_learner;
};


// Functions //

O_data::O_data()
{
        size = -1;
        states2dates = NULL;
        dates2states = NULL;
}

O_data::O_data(const O_data & datain)
{
        size = datain.size;
        dates2states = datain.dates2states;
        state_vect = datain.state_vect;
}

O_data::~O_data()
{
        delete dates2states;
        delete states2dates;
}

template<class O_DataType>
void O_data::freestates()
{
        vector<O_label *>::reverse_iterator O_it;
        for(O_it = state_vect.rbegin();O_it != state_vect.rend();++O_it)
        {
                //cout<<*(O_DataType*)(*O_it)<<endl;
                //delete (O_DataType*)(*O_it);
                state_vect.pop_back();
        }
        size = state_vect.size();
}

int O_data::get_size()
{
        return state_vect.size();
}

template<class O_DataType>
void O_data::start()
{
        if(size <= 0)
        {
                O_DataType * newdata = new O_DataType();
                state_vect.push_back((O_label*)newdata);
                size = state_vect.size();
                dates2states = new map<int,int>();
                (*dates2states)[0]=0;
                states2dates = new map<int,int>();
                (*states2dates)[0]=0;
        }
}

void O_data::clear_vect()
{
        state_vect.clear();
        size = state_vect.size();
}

template<class O_DataType>
int O_data::add(int date, O_label* labelin)
{
        if (state_vect.size()<1)
        {
                start<O_DataType>();
        }
        
        state_vect.push_back(labelin);
        add_state(size, date);
        add_date(date, size);
        size = state_vect.size();
        return (size-1);
}

// dates to states functions

void O_data::add_date(O_label & labelin)
{
        (*dates2states)[labelin.get_bufferef()]=labelin.get_statenb();
}

void O_data::add_date(int datein, int statenb)
{
        (*dates2states)[datein]=statenb;
}

int O_data::get_state(int date)
{
        map<int,int>::iterator mapit;
        mapit = dates2states->upper_bound(date);
        --mapit;
        return (*mapit).second;
}

void O_data::reset_D2S()
{
        if (dates2states != NULL)
                dates2states->clear();
}

// states to dates functions
void O_data::add_state(O_label & labelin)
{
        (*states2dates)[labelin.get_statenb()]=labelin.get_bufferef();
}

void O_data::add_state(int statenb, int datein)
{
        (*states2dates)[statenb]=datein;
}

int O_data::get_date(int statenb)
{
        return (*states2dates)[statenb];
}

void O_data::reset_S2D()
{
        if (states2dates != NULL)
                states2dates->clear();
}

// operator overload
O_label * O_data::operator[] (int i) const
{
        if (this!= NULL && size>0 && i<size)
                return(state_vect[i]);
        else
                return NULL;
}

#endif