fdstream.h

Go to the documentation of this file.

//      fdstream.h
//
// Input and output streams which use UNIX file descriptors.
//
// This code is adapted from the examples in the book:
// The C++ Stanbdard Library A Tutorial and Reference
// by Nicolai M. Josuttis
/*
 *
 *      Copyright 2007 - 2016 Brenton Ross
 *
 *   This code is part of VICI.
 *
 *   VICI 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.
 *
 *   VICI 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 GNU General Public License
 *   along with VICI.  If not, see <http://www.gnu.org/licenses/>.
 */

#ifndef CFI_FDSTREAM_H
#define CFI_FDSTREAM_H


#include <iostream>
#include <string>

namespace VICI
{

namespace cfi
{
//
// Forward declarations.
//
class fdostream;
class fdistream;


class FD
{
private:
        int fd;                         
        bool locked;            
public:

        FD( const std::string & name, int mode, bool lock );


        FD( int x ) : fd(x), locked(false) {}

        ~FD();

        operator int () { return fd; }


        static void report( std::ostream &s, int fd);
};



// -----------------------------------------------------------------
//      f d o b u f
// -----------------------------------------------------------------


class fdoutbuf : public std::streambuf
{
protected:
        fdostream & mOwner;

        int mFd;

        bool mIsCloseNeeded;

        static const int BUFFER_SIZE = 8192;

        char mBuffer[BUFFER_SIZE];


public:

        fdoutbuf( int fd, bool isCloseNeeded, fdostream & owner );


        void close();

        virtual ~fdoutbuf();


protected:
        int flushBuffer();


        virtual int overflow( int c );

        virtual int sync();
};


// -----------------------------------------------------------------
//      f d o s t r e a m
// -----------------------------------------------------------------


class fdostream : public std::ostream
{
public:
        static bool CLOSE_NEEDED;                       
        static bool CLOSE_NOT_NEEDED;           

        friend class fdoutbuf;

protected:
        fdoutbuf mBuf;

public:

        fdostream( int fd, bool isCloseNeeded = false );

        void close();
};


// -----------------------------------------------------------------
//      f d i n b u f
// -----------------------------------------------------------------


class fdinbuf : public std::streambuf
{
protected:
        fdistream & mOwner;

        int mFd;

        bool mIsCloseNeeded;

        static const int BUFFER_SIZE = 8192;    
        static const int PUSHBACK_SIZE = 4;             

        char mBuffer[BUFFER_SIZE + PUSHBACK_SIZE];


public:
        //
        // Constructor which accepts the file descriptor to read from,
        // a flag indicating whether the file descriptor is closed on
        // destruction, and our owning input stream.
        //


        fdinbuf( int fd, bool isCloseNeeded, fdistream & owner );

        void close();

        virtual ~fdinbuf();


protected:
        virtual int underflow();
};


// -----------------------------------------------------------------
//      f d i s t r e a m
// -----------------------------------------------------------------


class fdistream : public std::istream
{
public:
        static bool CLOSE_NEEDED;                       
        static bool CLOSE_NOT_NEEDED;           

        friend class fdinbuf;

protected:
        fdinbuf mBuf;

public:

        fdistream( int fd, bool isCloseNeeded = false );

        //
        // Close the input file descriptor if necessary.
        // This will be done whether or not the close needed flag is set.
        //

        void close();
};

} // namespace cfi
} // namespace VICI

#endif