// (Log is kept at end of this file)
#include <ctype.h> // isspace()
-#include "fgstream.hxx"
+#include <Misc/fgstream.hxx>
+
+fg_gzifstream::fg_gzifstream()
+ : istream(&gzbuf)
+{
+}
//-----------------------------------------------------------------------------
//
// Open a possibly gzipped file for reading.
//
-fg_gzifstream::fg_gzifstream( const string& name, int io_mode )
+fg_gzifstream::fg_gzifstream( const string& name, ios_openmode io_mode )
+ : istream(&gzbuf)
{
- open( name, io_mode );
+ this->open( name, io_mode );
}
//-----------------------------------------------------------------------------
//
// Attach a stream to an already opened file descriptor.
//
-fg_gzifstream::fg_gzifstream( int fd, int io_mode )
- : gzstream( fd, io_mode )
+fg_gzifstream::fg_gzifstream( int fd, ios_openmode io_mode )
+ : istream(&gzbuf)
{
+ gzbuf.attach( fd, io_mode );
}
//-----------------------------------------------------------------------------
// then append ".gz" and try again.
//
void
-fg_gzifstream::open( const string& name, int io_mode )
+fg_gzifstream::open( const string& name, ios_openmode io_mode )
{
- gzstream.open( name.c_str(), io_mode );
- if ( gzstream.fail() )
+ gzbuf.open( name.c_str(), io_mode );
+ if ( ! gzbuf.is_open() )
{
string s = name;
if ( s.substr( s.length() - 3, 3 ) == ".gz" )
}
// Try again.
- gzstream.open( s.c_str(), io_mode );
+ gzbuf.open( s.c_str(), io_mode );
}
}
-//-----------------------------------------------------------------------------
-//
-// Remove whitespace characters from the stream.
-//
-istream&
-fg_gzifstream::eat_whitespace()
-{
- char c;
- while ( gzstream.get(c) )
- {
- if ( ! isspace( c ) )
- {
- // put pack the non-space character
- gzstream.putback(c);
- break;
- }
- }
- return gzstream;
-}
-
-//-----------------------------------------------------------------------------
-//
-// Remove whitspace chatacters and comment lines from a stream.
-//
-istream&
-fg_gzifstream::eat_comments()
+void
+fg_gzifstream::attach( int fd, ios_openmode io_mode )
{
- for (;;)
- {
- // skip whitespace
- eat_whitespace();
-
- char c;
- gzstream.get( c );
- if ( c != '#' )
- {
- // not a comment
- gzstream.putback(c);
- break;
- }
-
- // skip to end of line.
- while ( gzstream.get(c) && (c != '\n' && c != '\r') )
- ;
- }
- return gzstream;
+ gzbuf.attach( fd, io_mode );
}
//
}
// $Log$
+// Revision 1.3 1998/11/06 14:05:12 curt
+// More portability improvements by Bernie Bright.
+//
// Revision 1.2 1998/09/24 15:22:17 curt
// Additional enhancements.
//
#endif
#ifdef HAVE_CONFIG_H
-# include "config.h"
+# include "Include/config.h"
#endif
#include <string>
-#include "Include/fg_stl_config.h"
-FG_USING_NAMESPACE(std);
+#include "Include/compiler.h"
+FG_USING_STD(string);
+
+// #ifdef FG_HAVE_STD_INCLUDES
+// #include <istream>
+// #else
+// #include <istream.h>
+// #endif
#include "zfstream.hxx"
+// Input stream manipulator function type.
+class fg_gzifstream;
+typedef fg_gzifstream& (*IManipFunc)( fg_gzifstream& );
+
//-----------------------------------------------------------------------------
//
// Envelope class for gzifstream.
//
-class fg_gzifstream
+class fg_gzifstream : private gzifstream_base, public istream
{
public:
//
// Attempt to open a file with and without ".gz" extension.
fg_gzifstream( const string& name,
- int io_mode = ios::in|ios::binary );
+ ios_openmode io_mode = ios_in | ios_binary );
//
- fg_gzifstream( int fd, int io_mode = ios::in|ios::binary );
+ fg_gzifstream( int fd, ios_openmode io_mode = ios_in|ios_binary );
// Attempt to open a file with and without ".gz" extension.
void open( const string& name,
- int io_mode = ios::in|ios::binary );
-
- // Return the underlying stream.
- istream& stream() { return gzstream; }
-
- // Check stream state.
- bool operator ! () const { return !gzstream; }
-
- // Check for end of file.
- bool eof() const { return gzstream.eof(); }
-
- // Remove whitespace from stream.
- // Whitespace is as defined by isspace().
- istream& eat_whitespace();
+ ios_openmode io_mode = ios_in|ios_binary );
- // Removes comments and whitespace from stream.
- // A comment is any line starting with '#'.
- istream& eat_comments();
-
- // Read one character from stream.
- istream& get( char& c ) { return gzstream.get(c); }
-
- // Put a character back into the input buffer.
- istream& putback( char c ) { return gzstream.putback(c); }
-
-private:
- // The underlying compressed data stream.
- gzifstream gzstream;
+ void attach( int fd, ios_openmode io_mode = ios_in|ios_binary );
private:
// Not defined!
fg_gzifstream( const fg_gzifstream& );
+ void operator= ( const fg_gzifstream& );
};
// istream manipulator that skips to end of line.
// A comment starts with '#'.
istream& skipcomment( istream& in );
+
#endif /* _FGSTREAM_HXX */
// $Log$
+// Revision 1.5 1998/11/06 14:05:13 curt
+// More portability improvements by Bernie Bright.
+//
// Revision 1.4 1998/10/16 00:50:56 curt
// Remove leading _ from a couple defines.
//
+// A C++ I/O streams interface to the zlib gz* functions
+//
+// Written by Bernie Bright, 1998
+// Based on zlib/contrib/iostream/ by Kevin Ruland <kevin@rodin.wustl.edu>
+//
+// Copyright (C) 1998 Bernie Bright - bbright@c031.aone.net.au
+//
+// 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 2 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 GNU General Public License
+// along with this program; if not, write to the Free Software
+// Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+//
+// $Id$
+// (Log is kept at end of this file)
#include <memory.h>
-#include "Misc/zfstream.hxx"
-
-gzfilebuf::gzfilebuf() :
- file(NULL),
- mode(0),
- own_file_descriptor(0)
-{ }
-
-gzfilebuf::~gzfilebuf() {
-
- sync();
- if ( own_file_descriptor )
- close();
-
-}
-
-gzfilebuf *gzfilebuf::open( const char *name,
- int io_mode ) {
-
- if ( is_open() )
- return NULL;
-
- char char_mode[10];
- char *p;
- memset(char_mode,'\0',10);
- p = char_mode;
-
- if ( io_mode & ios::in ) {
- mode = ios::in;
- *p++ = 'r';
- } else if ( io_mode & ios::app ) {
- mode = ios::app;
- *p++ = 'a';
- } else {
- mode = ios::out;
- *p++ = 'w';
- }
-
- if ( io_mode & ios::binary ) {
- mode |= ios::binary;
- *p++ = 'b';
- }
-
- // Hard code the compression level
- if ( io_mode & (ios::out|ios::app )) {
- *p++ = '9';
- }
-
- if ( (file = gzopen(name, char_mode)) == NULL )
- return NULL;
-
- own_file_descriptor = 1;
-
- return this;
-
-}
-
-gzfilebuf *gzfilebuf::attach( int file_descriptor,
- int io_mode ) {
-
- if ( is_open() )
- return NULL;
-
- char char_mode[10];
- char *p;
- memset(char_mode,'\0',10);
- p = char_mode;
-
- if ( io_mode & ios::in ) {
- mode = ios::in;
- *p++ = 'r';
- } else if ( io_mode & ios::app ) {
- mode = ios::app;
- *p++ = 'a';
- } else {
- mode = ios::out;
- *p++ = 'w';
- }
-
- if ( io_mode & ios::binary ) {
- mode |= ios::binary;
- *p++ = 'b';
- }
-
- // Hard code the compression level
- if ( io_mode & (ios::out|ios::app )) {
- *p++ = '9';
- }
-
- if ( (file = gzdopen(file_descriptor, char_mode)) == NULL )
- return NULL;
-
- own_file_descriptor = 0;
-
- return this;
-
+#include "zfstream.hxx"
+
+const int gzfilebuf::page_size;
+
+//
+// Construct a gzfilebuf object.
+// Allocate memory for 'get' buffer and zero all buffer pointers.
+//
+gzfilebuf::gzfilebuf()
+ : streambuf(),
+ file(NULL),
+ mode(0),
+ own_file_descriptor(false),
+ ibuf_size(0),
+ ibuffer(0)
+{
+// try {
+ ibuf_size = page_size / sizeof(char);
+ ibuffer = new char [ibuf_size];
+// } catch (...) {
+// delete [] ibuffer;
+// }
+
+ // Null get and set pointers.
+ this->setg(0,0,0);
+ this->setp(0,0);
}
-gzfilebuf *gzfilebuf::close() {
-
- if ( is_open() ) {
-
+gzfilebuf::~gzfilebuf()
+{
sync();
- gzclose( file );
- file = NULL;
-
- }
-
- return this;
-
+ if ( own_file_descriptor )
+ this->close();
+ delete [] ibuffer;
}
-int gzfilebuf::setcompressionlevel( short comp_level ) {
-
- return gzsetparams(file, comp_level, -2);
+void
+gzfilebuf::cvt_iomode( char* p, ios_openmode io_mode )
+{
+// memset( char_mode, '\0', 10 );
+// char* p = char_mode;
-}
+ if ( io_mode & ios_in )
+ {
+ mode = ios_in;
+ *p++ = 'r';
+ }
+ else if ( io_mode & ios_app )
+ {
+ mode = ios_app;
+ *p++ = 'a';
+ }
+ else
+ {
+ mode = ios_out;
+ *p++ = 'w';
+ }
-int gzfilebuf::setcompressionstrategy( short comp_strategy ) {
+ if ( io_mode & ios_binary )
+ {
+ mode |= ios_binary;
+ *p++ = 'b';
+ }
- return gzsetparams(file, -2, comp_strategy);
+ // Hard code the compression level
+ if ( io_mode & (ios_out | ios_app) )
+ {
+ *p++ = '9';
+ }
+ *p = '\0';
}
+gzfilebuf*
+gzfilebuf::open( const char *name, ios_openmode io_mode )
+{
+ if ( is_open() )
+ return NULL;
-streampos gzfilebuf::seekoff( streamoff off, ios::seek_dir dir, int which ) {
+ char char_mode[10];
+ cvt_iomode( char_mode, io_mode );
+ if ( (file = gzopen(name, char_mode)) == NULL )
+ return NULL;
- return streampos(EOF);
+ own_file_descriptor = true;
+ return this;
}
-int gzfilebuf::underflow() {
-
- // If the file hasn't been opened for reading, error.
- if ( !is_open() || !(mode & ios::in) )
- return EOF;
-
- // if a buffer doesn't exists, allocate one.
- if ( !base() ) {
+gzfilebuf*
+gzfilebuf::attach( int file_descriptor, ios_openmode io_mode )
+{
+ if ( is_open() )
+ return NULL;
- if ( (allocate()) == EOF )
- return EOF;
- setp(0,0);
+ char char_mode[10];
+ cvt_iomode( char_mode, io_mode );
+ if ( (file = gzdopen(file_descriptor, char_mode)) == NULL )
+ return NULL;
- } else {
+ own_file_descriptor = false;
- if ( in_avail() )
- return (unsigned char) *gptr();
+ return this;
+}
- if ( out_waiting() ) {
- if ( flushbuf() == EOF )
- return EOF;
+gzfilebuf*
+gzfilebuf::close()
+{
+ if ( is_open() )
+ {
+ sync();
+ gzclose( file );
+ file = NULL;
}
- }
+ return this;
+}
- // Attempt to fill the buffer.
+// int
+// gzfilebuf::setcompressionlevel( int comp_level )
+// {
+// return gzsetparams(file, comp_level, -2);
+// }
- int result = fillbuf();
- if ( result == EOF ) {
- // disable get area
- setg(0,0,0);
- return EOF;
- }
+// int
+// gzfilebuf::setcompressionstrategy( int comp_strategy )
+// {
+// return gzsetparams(file, -2, comp_strategy);
+// }
- return (unsigned char) *gptr();
+streampos
+gzfilebuf::seekoff( streamoff, ios_seekdir, int )
+{
+ return streampos(EOF);
}
-int gzfilebuf::overflow( int c ) {
-
- if ( !is_open() || !(mode & ios::out) )
- return EOF;
-
- if ( !base() ) {
- if ( allocate() == EOF )
- return EOF;
- setg(0,0,0);
- } else {
- if (in_avail()) {
+gzfilebuf::int_type
+gzfilebuf::overflow( int_type )
+{
+#if 0
+ if ( !is_open() || !(mode & ios::out) )
return EOF;
+
+ if ( !base() )
+ {
+ if ( allocate() == EOF )
+ return EOF;
+ setg(0,0,0);
}
- if (out_waiting()) {
- if (flushbuf() == EOF)
- return EOF;
+ else
+ {
+ if (in_avail())
+ {
+ return EOF;
+ }
+
+ if (out_waiting())
+ {
+ if (flushbuf() == EOF)
+ return EOF;
+ }
}
- }
-
- int bl = blen();
- setp( base(), base() + bl);
-
- if ( c != EOF ) {
-
- *pptr() = c;
- pbump(1);
-
- }
-
- return 0;
-}
-
-int gzfilebuf::sync() {
-
- if ( !is_open() )
- return EOF;
-
- if ( out_waiting() )
- return flushbuf();
-
- return 0;
+ int bl = blen();
+ setp( base(), base() + bl);
+ if ( c != EOF )
+ {
+ *pptr() = c;
+ pbump(1);
+ }
+#endif
+ return 0;
}
-int gzfilebuf::flushbuf() {
-
- int n;
- char *q;
-
- q = pbase();
- n = pptr() - q;
-
- if ( gzwrite( file, q, n) < n )
- return EOF;
-
- setp(0,0);
+int
+gzfilebuf::sync()
+{
+ if ( !is_open() )
+ return EOF;
- return 0;
+ if ( pptr() != 0 && pptr() > pbase() )
+ return flushbuf();
+ return 0;
}
-int gzfilebuf::fillbuf() {
-
- int required;
- char *p;
-
- p = base();
-
- required = blen();
-
- int t = gzread( file, p, required );
-
- if ( t <= 0) return EOF;
+gzfilebuf::int_type
+gzfilebuf::flushbuf()
+{
+ char* q = pbase();
+ int n = pptr() - q;
- setg( base(), base(), base()+t);
+ if ( gzwrite( file, q, n) < n )
+ return traits_type::eof();
- return t;
+ setp(0,0);
+ return 0;
}
-gzfilestream_common::gzfilestream_common() :
- ios( gzfilestream_common::rdbuf() )
-{ }
-
-gzfilestream_common::~gzfilestream_common()
-{ }
-
-void gzfilestream_common::attach( int fd, int io_mode ) {
-
- if ( !buffer.attach( fd, io_mode) )
- clear( ios::failbit | ios::badbit );
- else
- clear();
-
+gzfilebuf::int_type
+gzfilebuf::underflow()
+{
+// cerr << "gzfilebuf::underflow(): gptr()=" << (void*)gptr() << endl;
+ // Error if the file not open for reading.
+ if ( !is_open() || !(mode & ios_in) )
+ return traits_type::eof();
+
+ // If the input buffer is empty then try to fill it.
+ if ( gptr() != 0 && gptr() < egptr() )
+ {
+ return int_type(*gptr());
+ }
+ else
+ {
+ return fillbuf() == EOF ? traits_type::eof() : int_type(*gptr());
+ }
}
-void gzfilestream_common::open( const char *name, int io_mode ) {
-
- if ( !buffer.open( name, io_mode ) )
- clear( ios::failbit | ios::badbit );
- else
- clear();
-
-}
+//
+// Load the input buffer from the underlying gz file.
+// Returns number of characters read, or EOF.
+//
+int
+gzfilebuf::fillbuf()
+{
+ int t = gzread( file, ibuffer, ibuf_size );
+ if ( t <= 0)
+ {
+ // disable get area
+ setg(0,0,0);
+ return EOF;
+ }
-void gzfilestream_common::close() {
+ // Set the input (get) pointers
+ setg( ibuffer, ibuffer, ibuffer+t );
- if ( !buffer.close() )
- clear( ios::failbit | ios::badbit );
+// cerr << "gzfilebuf::fillbuf():"
+// << " t=" << t
+// << ", ibuffer=" << (void*)ibuffer
+// << ", ibuffer+t=" << (void*)(ibuffer+t) << endl;
+ return t;
}
-gzfilebuf *gzfilestream_common::rdbuf() {
-
- return &buffer;
-
-}
-
-gzifstream::gzifstream() :
- ios( gzfilestream_common::rdbuf() )
+#if 0
+gzifstream::gzifstream()
+ : istream(&buffer), buffer()
{
- clear( ios::badbit );
+ clear( ios_badbit );
}
-gzifstream::gzifstream( const char *name, int io_mode ) :
- ios( gzfilestream_common::rdbuf() )
+gzifstream::gzifstream( const char *name, ios_openmode io_mode )
+ : istream(&buffer), buffer()
{
- gzfilestream_common::open( name, io_mode );
+ this->open( name, io_mode );
}
-gzifstream::gzifstream( int fd, int io_mode ) :
- ios( gzfilestream_common::rdbuf() )
+gzifstream::gzifstream( int fd, ios_openmode io_mode )
+ : istream(&buffer), buffer()
{
- gzfilestream_common::attach( fd, io_mode );
+ buffer.attach( fd, io_mode );
}
-gzifstream::~gzifstream() { }
-
-gzofstream::gzofstream() :
- ios( gzfilestream_common::rdbuf() )
+gzifstream::~gzifstream()
{
- clear( ios::badbit );
}
-gzofstream::gzofstream( const char *name, int io_mode ) :
- ios( gzfilestream_common::rdbuf() )
+void
+gzifstream::open( const char *name, ios_openmode io_mode )
{
- gzfilestream_common::open( name, io_mode );
+ if ( !buffer.open( name, io_mode ) )
+ clear( ios_failbit | ios_badbit );
+ else
+ clear();
}
-gzofstream::gzofstream( int fd, int io_mode ) :
- ios( gzfilestream_common::rdbuf() )
+void
+gzifstream::close()
{
- gzfilestream_common::attach( fd, io_mode );
+ if ( !buffer.close() )
+ clear( ios_failbit | ios_badbit );
}
+#endif
-gzofstream::~gzofstream() { }
+// $Log$
+// Revision 1.2 1998/11/06 14:05:14 curt
+// More portability improvements by Bernie Bright.
+//
+// A C++ I/O streams interface to the zlib gz* functions
+//
+// Written by Bernie Bright, 1998
+// Based on zlib/contrib/iostream/ by Kevin Ruland <kevin@rodin.wustl.edu>
+//
+// Copyright (C) 1998 Bernie Bright - bbright@c031.aone.net.au
+//
+// 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 2 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 GNU General Public License
+// along with this program; if not, write to the Free Software
+// Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+//
+// $Id$
+// (Log is kept at end of this file)
#ifndef _zfstream_hxx
#define _zfstream_hxx
-#include <fstream.h>
-
#include "zlib/zlib.h"
-#include "Include/fg_stl_config.h"
+#include "Include/compiler.h"
-class gzfilebuf : public streambuf {
+#ifdef FG_HAVE_STD_INCLUDES
-public:
+# include <streambuf>
+# include <istream>
- gzfilebuf( );
- virtual ~gzfilebuf();
+# define ios_openmode ios_base::openmode
+# define ios_in ios_base::in
+# define ios_out ios_base::out
+# define ios_app ios_base::app
+# define ios_binary ios_base::binary
- gzfilebuf *open( const char *name, int io_mode );
- gzfilebuf *attach( int file_descriptor, int io_mode );
- gzfilebuf *close();
+# define ios_seekdir ios_base::seekdir
- int setcompressionlevel( short comp_level );
- int setcompressionstrategy( short comp_strategy );
+# define ios_badbit ios_base::badbit
+# define ios_failbit ios_base::failbit
- inline int is_open() const { return (file !=NULL); }
+#else
- virtual streampos seekoff( streamoff, ios::seek_dir, int );
+# ifdef FG_HAVE_STREAMBUF
+# include <streambuf.h>
+# include <istream.h>
+# else
+# include <iostream.h>
+# endif
- virtual int sync();
+//# define ios_openmode ios::open_mode
+# define ios_openmode int
+# define ios_in ios::in
+# define ios_out ios::out
+# define ios_app ios::app
+# define ios_binary ios::binary
-protected:
+# define ios_seekdir ios::seek_dir
- virtual int underflow();
- virtual int overflow( int = EOF );
+# define ios_badbit ios::badbit
+# define ios_failbit ios::failbit
-private:
+// Dummy up some char traits for now.
+template<class charT> struct char_traits{};
- gzFile file;
- short mode;
- short own_file_descriptor;
-
- int flushbuf();
- int fillbuf();
+FG_TEMPLATE_NULL
+struct char_traits<char>
+{
+ typedef char char_type;
+ typedef int int_type;
+ typedef streampos pos_type;
+ typedef streamoff off_type;
+ static int_type eof() { return EOF; }
};
-class gzfilestream_common : virtual public ios {
-
-// friend class gzifstream;
- friend class gzofstream;
- friend gzofstream &setcompressionlevel( gzofstream &, int );
- friend gzofstream &setcompressionstrategy( gzofstream &, int );
+#endif // FG_HAVE_STD_INCLUDES
+//-----------------------------------------------------------------------------
+//
+//
+//
+class gzfilebuf : public streambuf
+{
public:
- virtual ~gzfilestream_common();
-
- void attach( int fd, int io_mode );
- void open( const char *name, int io_mode );
- void close();
-protected:
- gzfilestream_common();
+#ifndef FG_HAVE_STD_INCLUDES
+ typedef char_traits<char> traits_type;
+ typedef char_traits<char>::int_type int_type;
+ typedef char_traits<char>::pos_type pos_type;
+ typedef char_traits<char>::off_type off_type;
+#endif
- gzfilebuf *rdbuf();
+ gzfilebuf();
+ virtual ~gzfilebuf();
-private:
-
- gzfilebuf buffer;
-
-};
+ gzfilebuf* open( const char* name, ios_openmode io_mode );
+ gzfilebuf* attach( int file_descriptor, ios_openmode io_mode );
+ gzfilebuf* close();
-class gzifstream : public gzfilestream_common, public istream {
+// int setcompressionlevel( int comp_level );
+// int setcompressionstrategy( int comp_strategy );
+ bool is_open() const { return (file != NULL); }
+ virtual streampos seekoff( streamoff off, ios_seekdir way, int which );
+ virtual int sync();
-public:
+protected:
- gzifstream();
- gzifstream( const char *name, int io_mode = ios::in );
- gzifstream( int fd, int io_mode = ios::in );
+ virtual int_type underflow();
+ virtual int_type overflow( int_type c = traits_type::eof() );
- virtual ~gzifstream();
+private:
-};
+ int_type flushbuf();
+ int fillbuf();
-class gzofstream : public gzfilestream_common, public ostream {
+ // Convert io_mode to "rwab" string.
+ void cvt_iomode( char* mode_str, ios_openmode io_mode );
-public:
+private:
- gzofstream();
- gzofstream( const char *name, int io_mode = ios::out );
- gzofstream( int fd, int io_mode = ios::out );
+ gzFile file;
+ ios_openmode mode;
+ bool own_file_descriptor;
- virtual ~gzofstream();
+ // Get (input) buffer.
+ int ibuf_size;
+ char* ibuffer;
-};
+ static const int page_size = 4096;
-template<class T> class gzomanip {
- friend gzofstream &operator << FG_NULL_TMPL_ARGS (gzofstream &, const gzomanip<T> &);
-public:
- gzomanip(gzofstream &(*f)(gzofstream &, T), T v) : func(f), val(v) { }
private:
- gzofstream &(*func)(gzofstream &, T);
- T val;
+ // Not defined
+ gzfilebuf( const gzfilebuf& );
+ void operator= ( const gzfilebuf& );
};
-template<class T> gzofstream &operator<<(gzofstream &s,
- const gzomanip<T> &m) {
- return (*m.func)(s, m.val);
-
-}
-
-inline gzofstream &setcompressionlevel( gzofstream &s, int l ) {
- (s.rdbuf())->setcompressionlevel(l);
- return s;
-}
-
-inline gzofstream &setcompressionstrategy( gzofstream &s, int l ) {
- (s.rdbuf())->setcompressionstrategy(l);
- return s;
-}
-
-inline gzomanip<int> setcompressionlevel(int l)
+//-----------------------------------------------------------------------------
+//
+//
+//
+struct gzifstream_base
{
- return gzomanip<int>( /* & */ setcompressionlevel,l); // & superfluous
-}
+ gzifstream_base() {}
-inline gzomanip<int> setcompressionstrategy(int l)
-{
- return gzomanip<int>( /* & */ setcompressionstrategy,l); // & superfluous
-}
+ gzfilebuf gzbuf;
+};
#endif // _zfstream_hxx
+
+// $Log$
+// Revision 1.4 1998/11/06 14:05:16 curt
+// More portability improvements by Bernie Bright.
+//
projects / simgear.git / commitdiff