UT/UT_FDStream.h

Go to the documentation of this file.

/*
 * PROPRIETARY INFORMATION.  This software is proprietary to
 * Side Effects Software Inc., and is not to be reproduced,
 * transmitted, or disclosed in any way without written permission.
 *
 * Produced by:
 *      Jeff Lait
 *      Side Effects Software Inc
 *      477 Richmond Street West
 *      Toronto, Ontario
 *      Canada   M5V 3E7
 *      416-504-9876
 *
 * NAME:        UT_FDStream.h ( UT Library, C++)
 *
 * COMMENTS:
 *      The original code, whose header is listed below, has been UTified.
 */

#ifndef __UT_FDStream__
#define __UT_FDStream__

#if !defined(UT_REALLY_USE_FD_STREAM)
- You should either have the line
#define UT_REALLY_USE_FD_STREAM
-
- Or, you should be using UT_FPStream
#error
#endif

#include "UT_API.h"

#if (defined(WIN32) && _MSC_VER >= 1300) || defined(GCC3)

/* 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()
 *                UT_FDInBuf::underflow(): cast for return statements
 *  Aug 05, 2001: first public version
 */

#include <istream>
#include <ostream>
#include <streambuf>
// for EOF:
#include <cstdio>
// for memmove():
#include <cstring>

// low-level read and write functions
#ifdef _MSC_VER
# include <io.h>
#else
# include <unistd.h>
//extern "C" {
//    int write (int fd, const char* buf, int num);
//    int read (int fd, char* buf, int num);
//}
#endif
#include "UT_Assert.h"

#ifdef GCC3
using namespace std;
#endif

/************************************************************
 * UT_OFDStream
 * - a stream that writes on a file descriptor
 ************************************************************/


class UT_API UT_FDOutBuf : public std::streambuf {
public:
    // constructor
    UT_FDOutBuf (int _fd) : myFD(_fd) { }

    void close()
    {
        UT_ASSERT(myFD >= 0);
        ::close(myFD);
        myFD = -1;
    }

protected:
    
    // write one character
    virtual int_type overflow (int_type c) 
    {
        UT_ASSERT(myFD >= 0);
        if (c != EOF) {
            char z = c;
            if (write (myFD, &z, 1) != 1) {
                return EOF;
            }
        }
        return c;
    }

    // In order to allow tellg to work, we need to provide seekoff.
    virtual pos_type    seekoff(off_type _Off,
                            ios_base::seekdir _Way,
                            ios_base::openmode /*_Mode*/ = ios::out)
    {
        // We only support seeking to the current position,
        // ie: telling.
        UT_ASSERT(myFD >= 0);
        UT_ASSERT(_Off == 0);
        UT_ASSERT(_Way == ios_base::cur);
#ifdef WIN32
        return (pos_type) _tell(myFD);
#else
        return (pos_type) lseek(myFD, 0, SEEK_CUR);
#endif
    }

    // write multiple characters
    virtual
    std::streamsize xsputn (const char* s,
                            std::streamsize num) 
    {
        UT_ASSERT(myFD >= 0);
        return write(myFD,s,num);
    }

protected:
    int myFD;    // file descriptor
};

class UT_API UT_OFDStream : public std::ostream {
  protected:
    UT_FDOutBuf buf;
  public:
    UT_OFDStream (int fd) : std::ostream(0), buf(fd) 
    {
        rdbuf(&buf);
    }

    void close()
    {
        buf.close();
    }
};


#else

    // This platform still uses old-school streams.
typedef ofstream        UT_OFDStream;

#endif

#endif

---