/usr/include/wvstreams/wvencoderstream.h is in libwvstreams-dev 4.6.1-11.
This file is owned by root:root, with mode 0o644.
The actual contents of the file can be viewed below.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 | /* -*- Mode: C++ -*-
* Worldvisions Tunnel Vision Software:
* Copyright (C) 1997-2002 Net Integration Technologies, Inc.
*
* An stream wrapper for encoders.
*/
#ifndef __WVENCODERSTREAM_H
#define __WVENCODERSTREAM_H
#include "wvstream.h"
#include "wvstreamclone.h"
#include "wvencoder.h"
/**
* WvEncoderStream chains a series of encoders on the input and
* output ports of the underlying stream to effect on-the-fly data
* transformations.
*
* Notice that the value of WvEncoderStream's auto_flush flag becomes
* important when working with encoders that treat explicit buffer
* flushing in a special manner. For instance, on flush() the Gzip
* encoder synchronizes its output. Were auto_flush to remain true,
* each incremental write to the stream would cause the Gzip encoder
* to flush its dictionary thereby resulting in poor compression.
*
* See WvStream::auto_flush(bool).
*
* WARNING: it is possible to add to the readchain and/or writechain in the
* middle of a session, for example to add gzip compression after first
* negotiating it with the remote end. If you plan to do this, be very
* careful with buffering. Never read() or getline() more bytes than
* you're sure will exist with the old encoding. Even then, only ever
* append things to the readchain, not prepend. (Therefore only prepend
* things to the writechain.) Always flush() or flush_write() before
* adding to the writechain. See also min_readsize.
*/
class WvEncoderStream : public WvStreamClone
{
bool is_closing;
WvDynBuf readinbuf;
WvDynBuf readoutbuf;
WvDynBuf writeinbuf;
//WvDynBuf writeoutbuf;
public:
/** Encoder chain through which input data is passed. */
WvEncoderChain readchain;
/** Encoder chain through which output data is passed. */
WvEncoderChain writechain;
/**
* Controls the minimum number of unencoded bytes the encoder
* should try to read at once from the underlying stream,
* to optimize performance of block-oriented protocols.
* This is not the same as queuemin() which guarantees how much
* encoded input must be generated before select() returns true.
* if 0, the encoder will only read whatever is specified in uread().
*
* NOTE: if you plan to append a new encoder to the readchain after
* doing read(), you should always use read() with only 1 byte at a
* time, or some extra data will end up in inbuf and not pass through
* the newly- added encoder. Remember that getline() also calls
* read(). The purpose of min_readsize is to make these one-byte
* read() calls more efficient, because the *underlying* stream can
* still read lots of bytes, as long as we only pass single bytes down
* to the WvEncoderStream.
*
* If you don't plan to add new encoders to readchain from now on, you
* can give larger sizes to read() or getline(), and thus min_readsize
* is unnecessary.
*/
size_t min_readsize;
/**
* Creates an encoder stream.
*
* "cloned" is the stream to wrap
*/
WvEncoderStream(WvStream *cloned);
virtual ~WvEncoderStream();
/**
* Safely shuts down the stream.
*
* Does the following in sequence:
*
* - Flushes and finishes the read chain
* - Flushes and finishes the write chain
* - Flushes the stream output buffers
* - Closes the underlying stream
*/
virtual void close();
/**
* Flushes the read chain through to the stream's input buffer.
*
* The regular stream flush() only operates on the write chain.
*
* Returns: true if the encoder chain returned true
*/
bool flush_read();
/**
* Flushes the write chain through to the stream's output buffer.
*
* The regular stream flush() invokes this, then attempts to
* synchronously push the buffered data to the stream, which
* may not always be desirable since it can be quite costly.
*
* To simply cause the write chain to be flushed but allow
* WvStreams to drain the encoded output buffer at its leisure,
* use this function.
*
* Returns: true if the encoder chain returned true
*/
bool flush_write();
/**
* Calls flush() then finish() on the read chain of encoders.
*
* Returns: true if the encoder chain returned true
*/
bool finish_read();
/**
* Calls flush() then finish() on the write chain of encoders.
*
* Does not flush() the stream.
*
* Returns: true if the encoder chain returned true.
*/
bool finish_write();
/**
* Defines isok() semantics for encoders.
*
* Returns false on error or after all data has been read from
* the internal buffers and readchain.isfinished() or
* ! writechain.isok().
*
* Returns: true if it is still possible to read and write data
*/
virtual bool isok() const;
virtual size_t uread(void *buf, size_t size);
virtual size_t uwrite(const void *buf, size_t size);
protected:
void pre_select(SelectInfo &si);
bool post_select(SelectInfo &si);
virtual bool flush_internal(time_t msec_timeout);
private:
void checkreadisok();
void checkwriteisok();
// pulls a chunk of specified size from the underlying stream
void pull(size_t size);
// pushes a chunk to the underlying stream
bool push(bool flush, bool finish);
public:
const char *wstype() const { return "WvEncoderStream"; }
};
#endif // __WVENCODERSTREAM_H
|