UT/UT_NTStreamUtil.h

Go to the documentation of this file.

#ifndef __UT_NTStreamUtil_H__
#define __UT_NTStreamUtil_H__

#include "UT_API.h"
#include <stdio.h>
#include <fstream.h>
#include <SYS/SYS_Types.h>
#include "UT_TmpDir.h"

#include <iostream.h>
#include <fstream.h>
typedef int UT_EnumType;
class UT_WorkBuffer;
class UT_String;
class UT_IStream;

typedef enum {
    UT_STRING_8BIT_IO = 8,
    UT_STRING_16BIT_IO = 16,
    UT_STRING_32BIT_IO = 32,
    UT_STRING_64BIT_IO = 64,
} UT_STRING_BINARY_IO;

#ifdef WIN32
    #include <strstrea.h>
    #define NTBinaryMode ios::binary
    
    void *getNewNamedPipe( char *pipeName );

    UT_API FILE *UnixPWrite( const char *cmd, const char *file );
    UT_API FILE *UnixPOpen( const char *file, const char *mode );
    UT_API void *UnixPOpen( const char *file, void **in, void **out,
                            void **err );
    UT_API int   UnixPClose( FILE *file, int block );
    inline FILE *popen( const char *name, const char *mode )
            { return UnixPOpen( name, mode ); }
    inline int   pclose( FILE *f, int block = 1 )
            { return UnixPClose( f, block ); }

    UT_API const char *UTgetSocketErrorString(int err);
#else
    #include <strstream.h>
    #define NTBinaryMode (std::ios::openmode)0
#endif  // WIN32

#define UT_NoCreate (std::ios::openmode)0

// Our portable and much improved strstream (basically defaults to
// 8 k blocks)
class UT_API UT_OStrStream : public ostrstream
{
public:
    UT_OStrStream();
    explicit UT_OStrStream(int reallocsize);
#if !defined(WIN32)
    UT_OStrStream(char *pch, int nLength, std::ios::openmode = std::ios::out)
    : ostrstream(pch, nLength) {}
#else
    UT_OStrStream(char *pch, int nLength, int nMode = ios::out)
    : ostrstream(pch, nLength, nMode) {}
#endif

    virtual ~UT_OStrStream() {}

private:
};

// A temporary stream that uses UT_OStrStream by default unless the buffer
// size is so big that it should be saved on disk. Tries to balance
// performance with the practicality of having large buffers stored
// in memory.
//
// NOTE: this class is not thread safe
//
class UT_API UT_TempStream
{
public:
    // construct a temporary stream
    // size_estimate - apporximate anticipated size of the buffer. This
    //    value is used to determine whether the buffer shaould be
    //    kept in memory or saved to hard drive.
     UT_TempStream( int size_estimate );
    ~UT_TempStream();

    // accesses the output stream for writing to the stream
    ostream             &getStream();

    // writes out the temp stream to an out stream
    void                 copyStream( ostream &out );

private:
    // TODO: implement a default constructor that uses UT_OStrStream
    // by default and automatically switches to iofstream 
    UT_TempStream();

private:
    UT_OStrStream       *myStrStream;   // memory buffer delegate
    fstream             *myFileStream;  // file buffer delegate
    UT_String           *myFileName;    // name of the temp file
};

#define DECLARE_PORTABLE_RW(type) \
    UT_API ostream &UTwrite( ostream &os, const type *src, int numelem = 1); \
    UT_API int UTfread( FILE *f, type *dest, int numelem = 1 ); \
    UT_API int UTfwrite( FILE *f, const type *src, int numelem = 1 );

DECLARE_PORTABLE_RW(char)
DECLARE_PORTABLE_RW(unsigned char)
DECLARE_PORTABLE_RW(signed char)
DECLARE_PORTABLE_RW(short)
DECLARE_PORTABLE_RW(unsigned short)
DECLARE_PORTABLE_RW(int)
DECLARE_PORTABLE_RW(unsigned int)
DECLARE_PORTABLE_RW(int64)
DECLARE_PORTABLE_RW(uint64)
DECLARE_PORTABLE_RW(fpreal32)
DECLARE_PORTABLE_RW(fpreal64)


// Save a chunk of binary data that may contain null characters.  Use
// UT_IStream::readBinaryData or UT_IStream::read(std::string &) to load
// it back in.
UT_API void UTsaveDataBinary(
    ostream &os, const char *data, int64 size,
    UT_STRING_BINARY_IO minbits=UT_STRING_16BIT_IO);
static inline void UTsaveDataBinary(
    ostream &os, const std::string &data,
    UT_STRING_BINARY_IO minbits=UT_STRING_16BIT_IO)
{ UTsaveDataBinary(os, data.c_str(), data.size(), minbits); }

// Save a string in a binary format.
UT_API void  UTsaveStringBinary(
    ostream &os, const char *str, UT_STRING_BINARY_IO minbits);

// Return the number of bytes required by UTsaveStringBinary() to save a string
// of the specified length.
UT_API uint64 UTgetNBytesToSaveStringBinary(
    uint64 stringlength, UT_STRING_BINARY_IO minbits);

UT_API void UTbuildDOSCommandLine(char *dest, const char * const *args);
UT_API void UTbuildDOSCommandLine(UT_WorkBuffer &buf, const char * const *args);

// Abstract base class for filtering the data before it is sent to the output
// stream.
class UT_API UT_StreamBufferFilter
{
public:
    // virtual destructor for derived classes
    virtual        ~UT_StreamBufferFilter()
                    {};

    // Often the filtering can efficently be performed only in multiple-byte
    // chunks, or the data may grow as a result of the filtering requiring that
    // the data is passed in smaller chunks than the actual buffer allocation
    // size. 
    // This method returns the the maximum input size (no larger than the
    // specified buffer size) with which the filter can work, given the buffer
    // size (sizes in bytes).
    virtual int     getDataChunkLength( int buffer_size )
                    { return buffer_size; }

    // Before the the data is sent to a filter, the filter may need to
    // initialize itself and/or write out some preamble.
    // This method lets the filter write the preamble data to the
    // buffer (up to a buffer_size), and return the data size actually written.
    // The stream_size is the total size of the stream that is going to be
    // filtered chunk by chunk.
    virtual int     beginFilter(char * /*buffer*/, int /*buffer_size*/,
                                int /*stream_size*/)
                    { return 0; }

    // Performs the filtering of the data in the buffer. The data size is
    // 'data_size' which may grow, shrink, or stay the same after filtering.
    // The filtered data length is returned by the method.
    virtual int     doFilterChunk( char *buffer, int data_size, 
                                   int buffer_size ) = 0;

    // After all the data has been sent to a filter, the filter may need
    // to return some remaining filtered data, which it did not have a chance
    // to process.
    // This method lets the filter write the filtered data to the
    // buffer (up to a buffer_size), and return the data size actually written.
    virtual int     endFilter( char * /*buffer*/, int /*buffer_size*/ )
                    { return 0; }
};

// Writes out the buffer to the output stream, but before it is written out
// the buffer is filtered using the given filter. The 'size' specifies the 
// length of the data to be filtered and written out.
UT_API bool UTwriteFiltered( ostream &os, const char *data, int size,
                             UT_StreamBufferFilter * filter );

// Copies the entire contents of the input stream into the output stream.
// Up to 'maxlen' bytes are read from the input stream. If the filter is
// specified, then the bytes read from the input stream are filtered before
// writing them to the output stream. If the filter is applied then the number 
// of written bytes may be different than the number of bytes read.
UT_API bool UTcopyStreamToStream(istream &is, ostream &os,
                                 size_t maxlen = ((size_t)-1),
                                 UT_StreamBufferFilter * filter = NULL);
UT_API bool UTcopyStreamToStream(UT_IStream &is, ostream &os,
                                 size_t maxlen = ((size_t)-1),
                                 UT_StreamBufferFilter * filter = NULL);

// Creates a unique temp file name. This name may conflict with an existing
// file, but the name will be unique among all _running_ Houdinis. In other
// words, it is safe to mindlessly overwrite the file with the given name.
UT_API void UTcreateTempFileName(UT_String &tempfile, const char *matchExt = 0);

// Tries to create the directory that will be required to hold the specified
// file.  Returns true if the dirctory exists of was created.
UT_API bool UTcreateDirectoryForFile(const char *filename);

// This function tells you whether or not you would block if you tried to
// read data from a file descriptor/the standard input.
UT_API bool UTisDataAvailableOnFD(int fd);
UT_API bool UTisDataAvailableOnStdin();
UT_API bool UTisStdinValid();

// This function will wait until either data is available on a file descriptor
// /stdin or until the specified timeout has passed.  The type of argument to
// the timeout is the same as the type of argument to sginap (10ms per clock
// tick).
UT_API void UTwaitForTimeoutOrDataOnFD(long clock_ticks, int fd);
UT_API void UTwaitForTimeoutOrDataOnStdin(long clock_ticks);

#endif  // __UT_NTStreamUtil_H__

---