FileIo.h

Go to the documentation of this file.

// -*- lsst-c++ -*-

/* 
 * LSST Data Management System
 * Copyright 2008, 2009, 2010 LSST Corporation.
 * 
 * This product includes software developed by the
 * LSST Project (http://www.lsst.org/).
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 * 
 * This program 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 General Public License for more details.
 * 
 * You should have received a copy of the LSST License Statement and 
 * the GNU General Public License along with this program.  If not, 
 * see <http://www.lsstcorp.org/LegalNotices/>.
 */
 

#ifndef LSST_AP_IO_FILE_IO_H
#define LSST_AP_IO_FILE_IO_H

#include <aio.h>
#include <zlib.h>

#include <string>

#include "boost/noncopyable.hpp"
#include "boost/scoped_array.hpp"

#include "../Common.h"


namespace lsst { namespace ap { namespace io {

class SequentialIoBase {

public :

    enum State {
        IN_PROGRESS = 0,
        FINISHED,
        FAILED
    };

    SequentialIoBase();

    virtual ~SequentialIoBase() = 0;

    bool finished() const { return _state == FINISHED; }

    bool failed() const { return _state == FAILED; }

    State getState() const { return _state; }

protected :

    State _state;
};


class SequentialReader : public SequentialIoBase {

public :

    virtual std::size_t read(unsigned char * const buf, std::size_t const len) = 0;
};


class SequentialWriter : public SequentialIoBase {

public :

    virtual void write(unsigned char const * const buf, std::size_t const len) = 0;

    virtual void finish() = 0;
};


class SequentialFileReader :
    public  SequentialReader,
    private boost::noncopyable
{

public:

    explicit SequentialFileReader(std::string const & fileName);

    virtual ~SequentialFileReader();
    virtual std::size_t read(unsigned char * const buf, std::size_t const size);

private :

    int _fd;

    void cleanup();
    void cleanup(State const state) {
        cleanup();
        _state = state;
    }
};


class SequentialFileWriter :
    public  SequentialWriter,
    private boost::noncopyable
{

public :

    explicit SequentialFileWriter(
        std::string const & fileName,
        bool        const   overwrite = false
    );

    virtual ~SequentialFileWriter();
    virtual void write(unsigned char const * const buf, std::size_t const len);
    virtual void finish();

private :

    int _fd;

    void cleanup();
    void cleanup(State const state) {
        cleanup();
        _state = state;
    }
};


class CompressedFileReader : public SequentialReader {

public :

    explicit CompressedFileReader(
        std::string const & fileName,
        std::size_t const   blockSize = 262144
    );

    virtual ~CompressedFileReader();
    virtual std::size_t read(unsigned char * const buf, std::size_t const size);

    std::size_t getBlockSize() const { return _blockSize; }

private :

    boost::scoped_array<unsigned char> _memory;
    unsigned char *   _buffers;   
    ::z_stream        _stream;    
    ::aiocb           _request;   
    std::size_t const _blockSize; 
    std::size_t       _fileSize;  
    std::size_t       _remaining; 
    int               _fd;        

    void cleanup();
    void cleanup(State const state) {
        cleanup();
        _state = state;
    }
};


class CompressedFileWriter : public SequentialWriter {

public :

    explicit CompressedFileWriter(
        std::string const & fileName,
        bool        const   overwrite = false,
        std::size_t const   blockSize = 262144
    );

    virtual ~CompressedFileWriter();

    virtual void write(unsigned char const * const buf, std::size_t const size);
    virtual void finish();

    std::size_t getBlockSize() const { return _blockSize; }

private :

    boost::scoped_array<unsigned char> _memory;
    unsigned char *   _buffers;   
    ::z_stream        _stream;    
    ::aiocb           _request;   
    std::size_t const _blockSize; 
    int               _fd;
    bool              _started;

    void cleanup();
    void cleanup(State const state) {
        cleanup();
        _state = state;
    }
};


}}}  // end of namespace lsst::ap::io

#endif // LSST_AP_IO_FILE_IO_H