Return to fstream.h CVS log

Up to [Research Unix] / researchv10no / cmd / cfront / libC / ooiostream

Annotation of researchv10no/cmd/cfront/libC/ooiostream/fstream.h, revision 1.1

1.1     ! root        1: /*ident        "@(#)ctrans:incl/fstream.h      1.1.1.2" */
        !             2: /**************************************************************************
        !             3:                         Copyright (c) 1984 AT&T
        !             4:                           All Rights Reserved   
        !             5: 
        !             6:         THIS IS UNPUBLISHED PROPRIETARY SOURCE CODE OF AT&T
        !             7:       
        !             8:         The copyright notice above does not evidence any        
        !             9:         actual or intended publication of such source code.
        !            10: 
        !            11: *****************************************************************************/
        !            12: #ifndef FSTREAMH
        !            13: #define FSTREAMH
        !            14: 
        !            15: #include <iostream.h>
        !            16: 
        !            17: class  filebuf : public streambuf {    /* a stream buffer for files */
        !            18: public:
        !            19:                        filebuf() ;
        !            20:                        filebuf(int fd);
        !            21:                        filebuf(int fd, char*  p, int l) ;
        !            22: 
        !            23:        int             is_open() { return opened ; }
        !            24:        int             fd() { return xfd ; }
        !            25:        filebuf*        open(const char *name, open_mode om, int prot=0664);
        !            26:        filebuf*        attach(int fd) ;
        !            27:        filebuf*        close() ;
        !            28:                        ~filebuf() ;
        !            29: public: /* virtuals */
        !            30:        virtual int     overflow(int=EOF);
        !            31:        virtual int     underflow();
        !            32:        virtual int     sync() ;
        !            33:        virtual streampos
        !            34:                        seekoff(streamoff,seek_dir,open_mode) ;
        !            35:        virtual streambuf*
        !            36:                        setbuf(char*  p, int len) ;
        !            37: protected:
        !            38:        int             xfd;    
        !            39:        open_mode       mode ;
        !            40:        char            opened;
        !            41:        streampos       last_seek ;
        !            42:        char*           in_start;
        !            43:        int             last_op();
        !            44:        char            lahead[2] ;
        !            45: };
        !            46: 
        !            47: class fstreambase : virtual public ios { 
        !            48: public:
        !            49:                        fstreambase() ;
        !            50:        
        !            51:                        fstreambase(const char* name, 
        !            52:                                        open_mode mode,int prot=0664) ;
        !            53:                        fstreambase(int fd) ;
        !            54:                        fstreambase(int fd, char*  p, int l) ;
        !            55:                        ~fstreambase() ;
        !            56:        void            open(const char* name, open_mode mode, int prot=0664) ;
        !            57:        void            attach(int fd);
        !            58:        void            close() ;
        !            59:        void            setbuf(char*  p, int l) ;
        !            60:        filebuf*        rdbuf() { return &buf ; }
        !            61: private:
        !            62:        filebuf         buf ;
        !            63: protected:
        !            64:        void            verify(int) ;
        !            65: } ;
        !            66: 
        !            67: class ifstream : public fstreambase, public istream {
        !            68: public:
        !            69:                        ifstream() ;
        !            70:                        ifstream(const char* name, 
        !            71:                                        open_mode mode,int prot=0664) ;
        !            72:                        ifstream(int fd) ;
        !            73:                        ifstream(int fd, char*  p, int l) ;
        !            74:                        ~ifstream() ;
        !            75: 
        !            76:        filebuf*        rdbuf() { return fstreambase::rdbuf(); }
        !            77:        void            open(const char* name, open_mode mode, int prot=0664) ;
        !            78: } ;
        !            79: 
        !            80: class ofstream : public fstreambase, public ostream {
        !            81: public:
        !            82:                        ofstream() ;
        !            83:                        ofstream(const char* name, 
        !            84:                                        open_mode mode,int prot=0664) ;
        !            85:                        ofstream(int fd) ;
        !            86:                        ofstream(int fd, char*  p, int l) ;
        !            87:                        ~ofstream() ;
        !            88: 
        !            89:        filebuf*        rdbuf() { return fstreambase::rdbuf(); }
        !            90:        void            open(const char* name, open_mode mode, int prot=0664) ;
        !            91: } ;
        !            92: 
        !            93: class fstream : public fstreambase, public iostream {
        !            94: public:
        !            95:                        fstream() ;
        !            96:        
        !            97:                        fstream(const char* name, 
        !            98:                                        open_mode mode,int prot=0664) ;
        !            99:                        fstream(int fd) ;
        !           100:                        fstream(int fd, char*  p, int l) ;
        !           101:                        ~fstream() ;
        !           102:        filebuf*        rdbuf() { return fstreambase::rdbuf(); }
        !           103:        void            open(const char* name, open_mode mode, int prot=0664) ;
        !           104: } ;
        !           105: 
        !           106: #endif

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