Writer.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 __WRITER_H_INCLUDED__
#define __WRITER_H_INCLUDED__

#include "GDF/RecordBuffer.h"
#include "GDF/EventHeader.h"
#include "GDF/GDFHeaderAccess.h"
#include <string>
#include <fstream>
#include <iostream>
#include <sstream>

namespace gdf
{
    enum WriterFlags
    {
        writer_ev_file      = 0,
        writer_ev_memory    = 1,
        writer_overwrite    = 2
    };


    class Writer : public RecordBuffer::RecordFullHandler
    {
    public:
        Writer( );

        virtual ~Writer( );


        void open( const int flags = writer_ev_file );


        void open( const std::string filename, const int flags = writer_ev_file );


        void close( );

        bool isOpen( );


        void setFilename( std::string filename );


        void setMaxFullRecords( size_t num );


        bool createSignal( size_t index, bool throwexc = false );


        void swapSignals( size_t a, size_t b );


        void relocateSignal( size_t src, size_t dst );

        size_t getFirstFreeSignalIndex( );


        void blitFromSerialBufferPhys( const double *buf, const std::vector<size_t> &samples_per_channel );


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


        template<typename T> void addSampleRaw( const size_t channel_idx, const T value )
        {
            m_recbuf.addSampleRaw<T>( channel_idx, value );
        }


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


        void blitSamplesPhys( const size_t channel_idx, const std::vector<float64> &values );


        template<typename T> void blitSamplesRaw( const size_t channel_idx, const T *values, size_t num )
        {
            m_recbuf.blitSamplesRaw<T>( channel_idx, values, num );
        }


        template<typename T> void blitSamplesRaw( const size_t channel_idx, const std::vector<T> &values )
        {
            m_recbuf.blitSamplesRaw<T>( channel_idx, &values[0], values.size() );
        }

        void addRecord( Record *r );

        Record *acquireRecord( );

        void writeRecordDirect( Record *r );

        void flush( );


        void setEventMode( uint8 mode );


        void setEventSamplingRate( float32 fs = -1 );

        void addEvent( const Mode1Event &ev );

        void addEvent( uint32 position, uint16 type );

        void addEvent( const Mode3Event &ev );

        void addEvent( uint32 position, uint16 type, uint16 channel, uint32 duration );

        void addEvent( uint32 position, uint16 type, uint16 channel, float32 value );

        const GDFHeaderAccess &getHeaderAccess_readonly( ) const { return m_header; }

        GDFHeaderAccess &getHeaderAccess( ) { return m_header; }

        const MainHeader &getMainHeader_readonly( ) const { return m_header.getMainHeader_readonly( ); }

        MainHeader &getMainHeader( ) { return m_header.getMainHeader( ); }

        const SignalHeader &getSignalHeader_readonly( size_t idx ) const { return m_header.getSignalHeader_readonly(idx); }

        inline size_t getNumSignals( ) const { return m_header.getNumSignals( ); }

        SignalHeader &getSignalHeader( size_t idx ) { return m_header.getSignalHeader(idx); }

    private:

        void writeRecord( );

        void writeEvents( );

        virtual void triggerRecordFull( Record *rec );

        RecordBuffer m_recbuf;
        GDFHeaderAccess m_header;
        std::fstream m_file;
        std::iostream m_eventbuffer;
        std::fstream m_evbuf_file;
        std::stringstream m_evbuf_memory;
        int m_eventbuffermemory;
        std::string m_filename;
        int64 m_num_datarecords;
        size_t max_full_records;
    };
}

#endif // __WRITER_H_INCLUDED__