Return to fstream.h CVS log

Up to [WindowsNT SDKs] / mstools / h

Annotation of mstools/h/fstream.h, revision 1.1.1.1

1.1       root        1: /***
                      2: *fstream.h - definitions/declarations for filebuf and fstream classes
                      3: *
                      4: *      Copyright (c) 1991-1992, Microsoft Corporation.  All rights reserved.
                      5: *
                      6: *Purpose:
                      7: *      This file defines the classes, values, macros, and functions
                      8: *      used by the filebuf and fstream classes.
                      9: *      [AT&T C++]
                     10: *
                     11: ****/
                     12: 
                     13: #ifndef _INC_FSTREAM
                     14: #define _INC_FSTREAM
                     15: 
                     16: #include <iostream.h>
                     17: 
                     18: // Force word packing to avoid possible -Zp override
                     19: #pragma pack(4)
                     20: 
                     21: #pragma warning(disable:4505)          // disable unwanted /W4 warning
                     22: // #pragma warning(default:4505)       // use this to reenable, if necessary
                     23: 
                     24: typedef int filedesc;
                     25: 
                     26: class filebuf : public streambuf {
                     27: public:
                     28: static const int       openprot;       // default share/prot mode for open
                     29: 
                     30: // optional share values for 3rd argument (prot) of open or constructor
                     31: static const int       sh_none;        // exclusive mode no sharing
                     32: static const int       sh_read;        // allow read sharing
                     33: static const int       sh_write;       // allow write sharing
                     34: // use (sh_read | sh_write) to allow both read and write sharing
                     35: 
                     36: // options for setmode member function
                     37: static const int       binary;
                     38: static const int       text;
                     39: 
                     40:                        filebuf();
                     41:                        filebuf(filedesc);
                     42:                        filebuf(filedesc, char *, int);
                     43:                        ~filebuf();
                     44: 
                     45:        filebuf*        attach(filedesc);
                     46:        filedesc        fd() const { return (x_fd==-1) ? EOF : x_fd; }
                     47:        int             is_open() const { return (x_fd!=-1); }
                     48:        filebuf*        open(const char *, int, int = filebuf::openprot);
                     49:        filebuf*        close();
                     50:        int             setmode(int = filebuf::text);
                     51: 
                     52: virtual        int             overflow(int=EOF);
                     53: virtual        int             underflow();
                     54: 
                     55: virtual        streambuf*      setbuf(char *, int);
                     56: virtual        streampos       seekoff(streamoff, ios::seek_dir, int);
                     57: // virtual     streampos       seekpos(streampos, int);
                     58: virtual        int             sync();
                     59: 
                     60: private:
                     61:        filedesc        x_fd;
                     62:        int             x_fOpened;
                     63: };
                     64: 
                     65: class ifstream : public istream {
                     66: public:
                     67:        ifstream();
                     68:        ifstream(const char *, int =ios::in, int = filebuf::openprot);
                     69:        ifstream(filedesc);
                     70:        ifstream(filedesc, char *, int);
                     71:        ~ifstream();
                     72: 
                     73:        streambuf * setbuf(char *, int);
                     74:        filebuf* rdbuf() const { return (filebuf*) ios::rdbuf(); }
                     75: 
                     76:        void attach(filedesc);
                     77:        filedesc fd() const { return rdbuf()->fd(); }
                     78: 
                     79:        int is_open() const { return rdbuf()->is_open(); }
                     80:        void open(const char *, int =ios::in, int = filebuf::openprot);
                     81:        void close();
                     82:        int setmode(int mode = filebuf::text) { return rdbuf()->setmode(mode); }
                     83: };
                     84: 
                     85: class ofstream : public ostream {
                     86: public:
                     87:        ofstream();
                     88:        ofstream(const char *, int =ios::out, int = filebuf::openprot);
                     89:        ofstream(filedesc);
                     90:        ofstream(filedesc, char *, int);
                     91:        ~ofstream();
                     92: 
                     93:        streambuf * setbuf(char *, int);
                     94:        filebuf* rdbuf() const { return (filebuf*) ios::rdbuf(); }
                     95: 
                     96:        void attach(filedesc);
                     97:        filedesc fd() const { return rdbuf()->fd(); }
                     98: 
                     99:        int is_open() const { return rdbuf()->is_open(); }
                    100:        void open(const char *, int =ios::out, int = filebuf::openprot);
                    101:        void close();
                    102:        int setmode(int mode = filebuf::text) { return rdbuf()->setmode(mode); }
                    103: };
                    104:        
                    105: class fstream : public iostream {
                    106: public:
                    107:        fstream();
                    108:        fstream(const char *, int, int = filebuf::openprot);
                    109:        fstream(filedesc);
                    110:        fstream(filedesc, char *, int);
                    111:        ~fstream();
                    112: 
                    113:        streambuf * setbuf(char *, int);
                    114:        filebuf* rdbuf() const { return (filebuf*) ostream::rdbuf(); }
                    115: 
                    116:        void attach(filedesc);
                    117:        filedesc fd() const { return rdbuf()->fd(); }
                    118: 
                    119:        int is_open() const { return rdbuf()->is_open(); }
                    120:        void open(const char *, int, int = filebuf::openprot);
                    121:        void close();
                    122:        int setmode(int mode = filebuf::text) { return rdbuf()->setmode(mode); }
                    123: };
                    124:        
                    125: // manipulators to dynamically change file access mode (filebufs only)
                    126: inline ios& binary(ios& _fstrm) \
                    127:    { ((filebuf*)_fstrm.rdbuf())->setmode(filebuf::binary); return _fstrm; }
                    128: inline ios& text(ios& _fstrm) \
                    129:    { ((filebuf*)_fstrm.rdbuf())->setmode(filebuf::text); return _fstrm; }
                    130: 
                    131: // Restore default packing
                    132: #pragma pack()
                    133: 
                    134: #endif         // !_INC_FSTREAM

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.