hackedteam/libmelter

/*
* Melter.cpp
*
*  Created on: Oct 4, 2010
*      Author: daniele
*/

#include <string>
#include <iostream>

#include "Melter.h"
#include "Chunk.h"
#include "IOManager.h"
#include "Mangler.h"

Melter::Melter(::prototype::Parser& parser, ::prototype::Mangler& mangler)
    : _parser(parser), _mangler(mangler), _defective(false)
{
    _io = new IOManager();
    _io->register_source_observer(*this);
}

Melter::~Melter()
{
    delete _io;
}

void Melter::setDefective(bool state)
{
    if(state)
    {
        _io->remove_source_observer(*this);
        _defective = true;
    }
}

bool Melter::isDefective()
{
    return _defective;
}

void Melter::update()
{
    if (!_io)
        assert(false);

    while ( _parser.num_registered_actions() && _io->available( _parser.descriptor() ) ) {
        std::string tag = _parser.tag();

        // get chunk and parse it, check for action expiration
        Chunk chunk = _io->read_for_parsing( _parser.descriptor() );
        bool expired = _parser.call( chunk );

        if(_parser.is_defective())
        {
            if(expired)
                _parser.expire_action();
            _io->append(chunk);

            break;
        }

        _mangler.call(*_io, _parser.tag(), chunk);
        
        if (expired)
            _parser.expire_action();
    }

    _io->process_pending();
}

std::size_t Melter::write( char const * data, std::size_t size )
{
    if (!data)
        return 0;

    
    if(_parser.is_defective() && !_defective)
        setDefective(true);


    Chunk chunk = Chunk( data, BufferDescriptor(0, size) );
    std::size_t ret_size = this->write( chunk );


    return ret_size;
}

std::size_t Melter::write( Chunk &chunk )
{
    if(_defective)
    {
        _io->append(chunk);
        return chunk.size();
    }

    return _io->append_to_input( chunk );
}

bool Melter::empty()
{
    return _io->empty();
}

Chunk Melter::read()
{
    return _io->read_from_output();
}