RecordBuffer.h

//
// This file is part of libGDF.
//
// libGDF is free software: you can redistribute it and/or modify
// it under the terms of the GNU Lesser General Public License as
// published by the Free Software Foundation, either version 3 of
// the License, or (at your option) any later version.
//
// libGDF is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU Lesser General Public License for more details.
//
// You should have received a copy of the GNU Lesser General Public License
// along with libGDF.  If not, see <http://www.gnu.org/licenses/>.
//
// Copyright 2010 Martin Billinger

#ifndef __RECORDBUFFER_H_INCLUDED__
#define __RECORDBUFFER_H_INCLUDED__

#include "GDF/Channel.h"
#include "GDF/pointerpool.h"

#include <list>
#include <vector>

namespace gdf
{
    class Record;
    class GDFHeaderAccess;


    class RecordBuffer
    {
    public:

        class RecordFullHandler
        {
        public:
            virtual void triggerRecordFull( Record *rec ) = 0;
        };

        RecordBuffer( const GDFHeaderAccess *gdfh );

        virtual ~RecordBuffer( );

        void clearBuffers( );

        void reset( );


        void handleChannelFull( const size_t channel_idx );


        void handleRecordFull( );

        void registerRecordFullCallback( RecordFullHandler *h );

        void unregisterRecordFullCallback( RecordFullHandler *h );

        void addSamplePhys( const size_t channel_idx, const double value );

        template<typename T> void addSampleRaw( const size_t channel_idx, const T rawval )
        {
            Channel *ch = getValidChannel( channel_idx );
            ch->addSampleRaw<T>( rawval );
            if( ch->getFree( ) == 0 )
                handleChannelFull( channel_idx );
        }

        void blitSamplesPhys( const size_t channel_idx, const double *values, size_t num );

        template<typename T> void blitSamplesRaw( const size_t channel_idx, const T *values, size_t num )
        {
            size_t i = 0;
            while( i<num )
            {
                Channel *ch = getValidChannel( channel_idx );
                size_t n = std::min( num-i, ch->getFree( ) );
                ch->blitSamplesRaw( &values[i], n );
                if( ch->getFree( ) == 0 )
                    handleChannelFull( channel_idx );
                i += n;
            }
        }

        void fillPhys( const size_t channel_idx, const double value, size_t num );

        template<typename T> void fillRaw( const size_t channel_idx, const T value, size_t num );


        void addRecord( Record *r );


        Record *acquireRecord( );

        std::list< Record* >::iterator createNewRecord( );

        Record *getFirstFullRecord( );

        void removeFirstFullRecord( );

        inline size_t getNumFullRecords( ) const { return m_num_full; }

        inline size_t getNumPartialRecords( ) const { return m_records.size( ); }


        Channel *getValidChannel( const size_t channel_idx );

        size_t getNumFreeAlloc( const size_t channel_idx );

        void flood( );

    protected:

    private:
        const GDFHeaderAccess *m_gdfh;
        PointerPool<Record> *m_pool;
        std::list< Record* > m_records;
        std::list< Record* > m_records_full;
        size_t m_num_full;
        std::vector< std::list< Record* >::iterator > m_channelhead;
        std::list<RecordFullHandler*> m_recfull_callbacks;
    };
}

#endif