fdstream.h

Go to the documentation of this file.

/* This software and supporting documentation are distributed by
 *     Institut Federatif de Recherche 49
 *     CEA/NeuroSpin, Batiment 145,
 *     91191 Gif-sur-Yvette cedex
 *     France
 *
 * This software is governed by the CeCILL-B license under
 * French law and abiding by the rules of distribution of free software.
 * You can  use, modify and/or redistribute the software under the
 * terms of the CeCILL-B license as circulated by CEA, CNRS
 * and INRIA at the following URL "http://www.cecill.info".
 *
 * As a counterpart to the access to the source code and  rights to copy,
 * modify and redistribute granted by the license, users are provided only
 * with a limited warranty  and the software's author,  the holder of the
 * economic rights,  and the successive licensors  have only  limited
 * liability.
 *
 * In this respect, the user's attention is drawn to the risks associated
 * with loading,  using,  modifying and/or developing or reproducing the
 * software by the user in light of its specific status of free software,
 * that may mean  that it is complicated to manipulate,  and  that  also
 * therefore means  that it is reserved for developers  and  experienced
 * professionals having in-depth computer knowledge. Users are therefore
 * encouraged to load and test the software's suitability as regards their
 * requirements in conditions enabling the security of their systems and/or
 * data to be ensured and,  more generally, to use and operate it in the
 * same conditions as regards security.
 *
 * The fact that you are presently reading this means that you have had
 * knowledge of the CeCILL-B license and that you accept its terms.
 */
 
#include <cartobase/config/cartobase_config.h>
 
/* The following code declares classes to read from and write to
 * file descriptore or file handles.
 *
 * See
 *      http://www.josuttis.com/cppcode
 * for details and the latest version.
 *
 * - open:
 *      - integrating BUFSIZ on some systems?
 *      - optimized reading of multiple characters
 *      - stream for reading AND writing
 *      - i18n
 *
 * (C) Copyright Nicolai M. Josuttis 2001.
 * Permission to copy, use, modify, sell and distribute this software
 * is granted provided this copyright notice appears in all copies.
 * This software is provided "as is" without express or implied
 * warranty, and with no claim as to its suitability for any purpose.
 *
 * Version: Jul 28, 2002
 * History:
 *  Jul 28, 2002: bugfix memcpy() => memmove()
 *                fdinbuf::underflow(): cast for return statements
 *  Aug 05, 2001: first public version
 */
#ifndef BOOST_FDSTREAM_HPP
#define BOOST_FDSTREAM_HPP
 
#if !defined( __GNUC__ ) || __GNUC__-0 >= 3
#include <istream>
#include <ostream>
#include <streambuf>
#else
#include <iostream>
#include <streambuf.h>
#include <string>
#endif
 
// BEGIN namespace BOOST
namespace boost {
 
 
/************************************************************
 * fdostream
 * - a stream that writes on a file descriptor
 ************************************************************/
 
 
class fdoutbuf : public std::streambuf {
  protected:
    int fd;    // file descriptor
#if defined( __GNUC__ ) && __GNUC__-0 < 3
    typedef int int_type;
#endif
#ifdef _WIN32
    // on windows we can't write() on a socket fd (!)
    bool _sock;
#endif
  public:
    // constructor
  fdoutbuf (int _fd );
 
  protected:
    // write one character
    virtual int_type overflow (int_type c);
    // write multiple characters
    virtual
    std::streamsize xsputn (const char* s,
                            std::streamsize num);
};
 
class fdostream : public std::ostream {
  protected:
    fdoutbuf buf;
  public:
    fdostream (int fd) : std::ostream(0), buf(fd) {
        rdbuf(&buf);
    }
};
 
 
/************************************************************
 * fdistream
 * - a stream that reads on a file descriptor
 ************************************************************/
 
class fdinbuf : public std::streambuf {
  protected:
    int fd;    // file descriptor
#ifdef _WIN32
    // on windows we can't read() on a socket fd (!)
    bool _sock;
#endif
  protected:
    /* data buffer:
     * - at most, pbSize characters in putback area plus
     * - at most, bufSize characters in ordinary read buffer
     */
    static const int pbSize = 4;        // size of putback area
    static const int bufSize = 1024;    // size of the data buffer
    char buffer[bufSize+pbSize];        // data buffer
#if defined( __GNUC__ ) && __GNUC__-0 < 3
    typedef int int_type;
    typedef string::traits_type traits_type;
#endif
 
  public:
    /* constructor
     * - initialize file descriptor
     * - initialize empty data buffer
     * - no putback area
     * => force underflow()
     */
  fdinbuf (int _fd);
 
  protected:
    // insert new characters into the buffer
    virtual int_type underflow ();
};
 
class fdistream : public std::istream {
  protected:
    fdinbuf buf;
  public:
    fdistream (int fd) : std::istream(0), buf(fd) {
        rdbuf(&buf);
    }
};
 
 
} // END namespace boost
 
#endif /*BOOST_FDSTREAM_HPP*/