hackedteam/vector-dropper

/*
 * DataState.h
 *
 *  Created on: Apr 27, 2010
 *      Author: daniele
 */

#ifndef DATASTATE_H_
#define DATASTATE_H_

#include <boost/statechart/result.hpp>
#include <boost/statechart/deep_history.hpp>
#include <boost/statechart/custom_reaction.hpp>
#include <boost/statechart/simple_state.hpp>
#include <boost/statechart/transition.hpp>
#include <boost/statechart/in_state_reaction.hpp>
namespace sc = boost::statechart;

#include "Common.h"
#include "Events.h"
#include "StreamingMelter.h"

enum StateResult {
        NEED_MORE_DATA,
        PARSED,
        PROCESSED,
    };

template< class Derived, class Outer >
struct DataState : sc::simple_state< Derived, Outer >
{
public:
    DataState()
        : done_(false), initialized_(false), parsed_(false)
    {
    }

    void feed ( char *data, std::size_t size )
    {
        this.template context<StreamingMelter>().feed(data, size);
        this->post_event( EvNewData() );
    }

    bool isTriggering()
    {
        if ( currentOffset() == triggeringOffset() && isDataAvailable() )
            return true;
        return false;
    }

    bool isDataAvailable()
    {
        return isDataAvailable( neededBytes() );
    }

    bool isDataAvailable(std::size_t bytes)
    {
        //DBGTRACE("isDataAvailable - available offset: ", availableOffset(), NOTIFY);
        //DBGTRACE("isDataAvailable - current offset  : ", currentOffset(), NOTIFY);
        //DBGTRACE("isDataAvailable - needed bytes    : ", bytes, NOTIFY);
        if ( availableOffset() - currentOffset() >= bytes )
            return true;
        return false;
    }

    sc::result canSwitchToNext()
    {
        if ( availableOffset() < offsetToNext() ) {
            std::size_t bytes = availableOffset() - currentOffset();
            this->template context<StreamingMelter>().complete( bytes );
            return this->discard_event();
        }

        std::size_t bytes = offsetToNext() - currentOffset();
        this->template context<StreamingMelter>().complete( bytes );
        this->post_event( EvNewData() );
        return transitToNext();
    }

    char* getData()
    {
        char *data = this->template context<StreamingMelter>().buffer()->data();
        if (!data)
                throw parsing_error("Invalid data pointer.");
        return data;
    }

    virtual void init() = 0;
    virtual StateResult parse() = 0;
    virtual StateResult process() { return PROCESSED; };
    virtual sc::result transitToNext() = 0;

    void preamble()
    {
    }

    sc::result react( const EvNewData & ev )
    {
        (void) ev;

        if ( ! initialized() )
        {
            init();
            initialized() = true;
        }

        //DBGTRACE_BUFFER(DEVDEBUG);

        if ( done() == false )
        {
            // check if we have enough data
            if ( ! isTriggering() ) {
                // DBGTRACE("NOT TRIGGERING", "", DEVDEBUG);
                return this->discard_event();
            }

            // DBGTRACE("TRIGGERING", "", DEVDEBUG);
            if (!parsed_) {
                if (parse() != PARSED)
                    return this->discard_event();
                parsed_ = true;
            }

            if (process() != PROCESSED)
                throw parsing_error("CRITICAL ERROR!!!");

            done() = true;
            // DBGTRACE("offset to next           : ", offsetToNext(), DEVDEBUG);
        }

        // DBGTRACE("running to next state in: ", offsetToNext() - currentOffset(), DEVDEBUG);
        return canSwitchToNext();
    }

    boost::shared_ptr<Chunk> output()
    {
        DEBUG_MSG(D_EXCESSIVE, "new data to offset: %08x", this.template context<StreamingMelter>().maxOffset());
        return this.template context<StreamingMelter>().output();
    }

    std::size_t currentOffset()
    {
        return this->template context<StreamingMelter>().currentOffset();
    }

    std::size_t availableOffset()
    {
        return this->template context<StreamingMelter>().maxOffset();
    }

    bool done() const { return done_; }
    bool & done() { return done_; }

    std::size_t neededBytes() const { return neededBytes_; }
    std::size_t& neededBytes() { return neededBytes_; }

    std::size_t triggeringOffset() const { return triggeringOffset_; }
    std::size_t& triggeringOffset() { return triggeringOffset_; }

    std::size_t offsetToNext() const { return offsetToNext_; }
    std::size_t& offsetToNext() { return offsetToNext_; }

    bool initialized() const { return initialized_; }
    bool& initialized() { return initialized_; }

    typedef mpl::list<
                sc::custom_reaction<EvNewData>,
                sc::transition<EvParsingFailed, Defective>
            > reactions;

protected:
    std::size_t neededBytes_;
    std::size_t triggeringOffset_;
    std::size_t offsetToNext_;
    bool done_;
    bool initialized_;
    bool parsed_;
};

#endif /* DATASTATE_H_ */