/* * *  C++ Portable Types Library (PTypes) *  Version 1.7.5   Released 9-Mar-2003 * *  Copyright (c) 2001, 2002, 2003 Hovik Melikyan * *  http://www.melikyan.com/ptypes/ *  http://ptypes.sourceforge.net/ * */#ifndef __PSTREAMS_H__#define __PSTREAMS_H__#ifndef __PPORT_H__#include "pport.h"#endif#ifndef __PTYPES_H__#include "ptypes.h"#endif#include <stdarg.h>#include <errno.h>#ifdef WIN32#  define _WINSOCKAPI_   // prevent inclusion of winsock.h, because we need winsock2.h#  include "windows.h"   // for OVERLAPPED#endifPTYPES_BEGIN#ifdef _MSC_VER#pragma pack(push, 4)#endif// -------------------------------------------------------------------- //// ---  abstract stream i/o classes ----------------------------------- //// -------------------------------------------------------------------- ////// stream exception class//class iobase;class ptpublic estream: public exceptobj {protected:    int code;    iobase* errstm;public:    estream(iobase* ierrstm, int icode, const char* imsg);    estream(iobase* ierrstm, int icode, const string& imsg);    virtual ~estream();    int get_code()          { return code; }    iobase* get_errstm()    { return errstm; }};typedef void (*iostatusevent)(iobase* sender, int code);ptpublic int unixerrno();ptpublic const char* unixerrmsg(int code);// status codes: compatible with WinInet API// additional status codes are defined in pinet.h for ipsocketconst int IO_CREATED = 1;const int IO_OPENING = 5;const int IO_OPENED = 35;const int IO_READING = 37;const int IO_WRITING = 38;const int IO_EOF = 45;const int IO_CLOSING = 250;const int IO_CLOSED = 253;//// iobase//enum ioseekmode {    IO_BEGIN,    IO_CURRENT,    IO_END};const int invhandle = -1;class ptpublic iobase: public component {    friend class fdxoutstm;protected:    bool    active;         // active status, changed by open() and close()    bool    cancelled;      // the stream was cancelled by cancel()    bool    eof;            // end of file reached, only for input streams    int     handle;         // used in many derivative classes    int     abspos;         // physical stream position    int     bufsize;        // buffer size, can be changed only when not active    char*   bufdata;        // internal: allocated buffer data    int     bufpos;         // internal: current position    int     bufend;         // internal: current data size in the buffer    int     stmerrno;       // UNIX-compatible error numbers, see comments in piobase.cxx    string  deferrormsg;    // internal: default error message when an exception is thrown,    int     status;         // stream status code, see IO_xxx constants above    iostatusevent onstatus; // user-defined status change handler    virtual void bufalloc();    virtual void buffree();    void bufclear() { bufpos = 0; bufend = 0; }    void errstminactive();    void errbufrequired();    virtual void doopen() = 0;    virtual void doclose();    virtual int  doseek(int newpos, ioseekmode mode);    virtual void chstat(int newstat);    virtual int uerrno();    virtual const char* uerrmsg(int code);public:    iobase(int ibufsize = -1);    virtual ~iobase();    void open();    void close();    void cancel();    int  seek(int newpos, ioseekmode mode = IO_BEGIN);    void error(int code, const char* defmsg);    virtual void flush();    virtual string get_errormsg();    virtual string get_errstmname();    virtual string get_streamname() = 0;    bool get_active()                               { return active; }    void set_active(bool newval);    bool get_cancelled()                            { return cancelled; }    void set_cancelled(bool newval)                 { cancelled = newval; }    int  get_handle()                               { return handle; }    int  get_bufsize()                              { return bufsize; }    void set_bufsize(int newval);    int  get_stmerrno()                             { return stmerrno; }    int  get_status()                               { return status; }    iostatusevent get_onstatus()                    { return onstatus; }    void set_onstatus(iostatusevent newval)         { onstatus = newval; }};typedef iobase* piobase;ptpublic extern int defbufsize;ptpublic extern int stmbalance;//// instm - abstract input stream//const char eofchar = 0;class ptpublic instm: public iobase {protected:    virtual int dorawread(char* buf, int count);    int rawread(char* buf, int count);    virtual void bufvalidate();    void skipeol();public:    instm(int ibufsize = -1);    virtual ~instm();    virtual int classid();    bool get_eof();    void set_eof(bool ieof)  { eof = ieof; }    bool get_eol();    int  get_dataavail();    char preview();    char get();    void putback();    string token(const cset& chars);    string token(const cset& chars, int limit);    int token(const cset& chars, char* buf, int size);    string line();    string line(int limit);    int line(char* buf, int size, bool eateol = true);    int read(void* buf, int count);    int skip(int count);    int skiptoken(const cset& chars);    void skipline(bool eateol = true);    int tell();    int seek(int newpos, ioseekmode mode = IO_BEGIN);};typedef instm* pinstm;//// outstm - abstract output stream//class ptpublic outstm: public iobase {protected:    bool flusheol;    virtual int dorawwrite(const char* buf, int count);    int rawwrite(const char* buf, int count);    virtual void bufvalidate();    void bufadvance(int delta)          { bufpos += delta; if (bufend < bufpos) bufend = bufpos; }    bool canwrite();public:    outstm(bool iflusheol = false, int ibufsize = -1);    virtual ~outstm();    virtual int classid();    bool get_flusheol()             { return flusheol; }    void set_flusheol(bool newval)  { flusheol = newval; }    virtual void flush();    bool get_eof()                  { return eof; }    void put(char c);    void put(const char* str);    void put(const string& str);    void vputf(const char* fmt, va_list);    void putf(const char* fmt, ...);    void putline(const char* str);    void putline(const string& str);    void puteol();    int  write(const void* buf, int count);    int  tell()                      { return abspos + bufpos; }    int  seek(int newpos, ioseekmode mode = IO_BEGIN);};typedef outstm* poutstm;//// internal class used in fdxstm//class ptpublic fdxoutstm: public outstm{    friend class fdxstm;protected:    fdxstm* in;    virtual void chstat(int newstat);    virtual int uerrno();    virtual const char* uerrmsg(int code);    virtual void doopen();    virtual void doclose();    virtual int dorawwrite(const char* buf, int count);public:    fdxoutstm(int ibufsize, fdxstm* iin);    virtual ~fdxoutstm();    virtual string get_streamname();};typedef fdxstm* pfdxstm;//// fdxstm: abstract full-duplex stream (for sockets and pipes)//class ptpublic fdxstm: public instm{    friend class fdxoutstm;protected:    fdxoutstm out;    virtual int dorawwrite(const char* buf, int count);public:    fdxstm(int ibufsize = -1);    virtual ~fdxstm();    void set_bufsize(int newval);       // sets both input and output buffer sizes    void open();            // rewritten to pass the call to the output stream too    void close();    void cancel();    virtual void flush();    int tell(bool);         // true for input and false for output    // output interface: pretend this class is derived both    // from instm and outstm. actually we can't use multiple    // inheritance here, since this is a full-duplex stream,    // hence everything must be duplicated for input and output    void putf(const char* fmt, ...);    void put(char c)                        { out.put(c); }    void put(const char* str)               { out.put(str); }    void put(const string& str)             { out.put(str); }    void putline(const char* str)           { out.putline(str); }    void putline(const string& str)         { out.putline(str); }    void puteol()                           { out.puteol(); }    int  write(const void* buf, int count)  { return out.write(buf, count); }    bool get_flusheol()                     { return out.get_flusheol(); }    void set_flusheol(bool newval)          { out.set_flusheol(newval); }    operator outstm&()			    { return out; }};//// abstract input filter class//class ptpublic infilter: public instm {protected:    instm*   stm;    char*    savebuf;    int      savecount;    string   postponed;    void copytobuf(string& s);    void copytobuf(pconst& buf, int& count);    bool copytobuf(char c);    virtual void freenotify(component* sender);    virtual void doopen();    virtual void doclose();    virtual int  dorawread(char* buf, int count);    virtual void dofilter() = 0;    bool bufavail()  { return savecount > 0; }    void post(const char* buf, int count);    void post(const char* s);    void post(char c);    virtual void post(string s);public:    infilter(instm* istm, int ibufsize = -1);    virtual ~infilter();    virtual string get_errstmname();    instm* get_stm()  { return stm; }    void set_stm(instm* stm);};//// abstract output filter class//class ptpublic outfilter: public outstm{protected:    outstm* stm;    virtual void freenotify(component* sender);    virtual void doopen();    virtual void doclose();public:    outfilter(outstm* istm, int ibufsize = -1);    virtual ~outfilter();    virtual string get_errstmname();