FileIOManager.h

/* -*- mode: c++ -*- */
#ifndef __DAQpp_FileIOManager_h__
#define __DAQpp_FileIOManager_h__

#include <zlib.h>
#include <DAQ++/Thread.h>
#include <fcntl.h>
#include <string>
#include <DAQ++/exception.h>

namespace DAQpp
{

class FileHeader;

class FileIOManager
{
public:
    typedef int (*HeaderFunc)(const char **, char *);

private:
    int fd;
    gzFile zfd;

    Mutex mtx;
    class IOthread : public Thread
    {
    private:
        FileIOManager *iom;
    public:
        IOthread(FileIOManager *_io) : iom(_io)
        {}
        void run()
        {
            if (iom)
                iom->spy_size();
        }
    };
    friend class IOthread;

    IOthread thread;

    std::string base_name;

    std::string extension;

    int ifile;

    bool zcomp;

    unsigned long _size;

    unsigned long _max_size;

    std::string file_name;

    void  spy_size();
    void  spy_size_intr();

    int    new_file();

    

    bool doSpy;

    int write_header_tail( HeaderFunc , char *);

public:
    HeaderFunc get_header;

    char *header_data;

    HeaderFunc get_tail;

    // Data that will be passed to HeaderFunc
    char *tail_data;

public:
    FileIOManager(bool use_compression, unsigned long mx_size );

    virtual ~FileIOManager();

    int open(const std::string &);

    int close();

    int write(const char *, size_t);

    virtual std::string new_name();
    
    int file_number()
    {
        return ifile;
    }

    void set_max_size(unsigned long x)
    {
        _max_size = x;
    }

    unsigned long size()
    {
        return _size;
    }

    double relative_size()
    {
        return ((double)_size) / ((double)_max_size);
    }

    void Compress(bool t)
    {
        zcomp = t;
    }

    bool Compress()
    {
        return zcomp;
    }

    const std::string &get_file_name() const
    {
        return file_name;
    }

    void set_header_func( HeaderFunc ff, char *dt )
    {
        header_data = dt;
        get_header = ff;
    }

    void reset_header_func()
    {
        get_header = 0;
    }

    void set_tail_func( HeaderFunc ff, char *dt )
    {
        tail_data = dt;
        get_tail = ff;
    }

    // removes the tail "getter"
    void reset_tail_func()
    {
        get_tail = 0;
    }
};



}

#endif

---