/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- * * The contents of this file are subject to the Netscape Public License * Version 1.0(the "NPL"); you may not use this file except in * compliance with the NPL. You may obtain a copy of the NPL at * http://www.mozilla.org/NPL/ * * Software distributed under the NPL is distributed on an "AS IS" basis, * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL * for the specific language governing rights and limitations under the * NPL. * * The Initial Developer of this code under the NPL is Netscape * Communications Corporation. Portions created by Netscape are * Copyright(C) 1998 Netscape Communications Corporation. All Rights * Reserved. */ #error "Do not use this file. The unix compilers do not support standard C++. Use nsFileStream" // First checked in on 98/11/20 by John R. McMullen in the wrong directory. // Checked in again 98/12/04. // Polished version 98/12/08. //======================================================================================== // // Classes defined: // // single-byte char: // // nsInputFileStream, nsOutputFileStream, nsIOFileStream // // wide char: // // nsWideInputFileStream, nsWideOutputFileStream, nsWideIOFileStream // // This suite provide the following services: // // 1. Encapsulates all platform-specific file details, so that file i/o // can be done correctly without any platform #ifdefs // // 2. Uses NSPR file services (NOT ansi file I/O), in order to get best // native performance. This performance difference is especially large on // macintosh. // // 3. Allows all the power of the ansi stream syntax: these streams // ARE derived classes of ostream, istream, and iostream. ALL METHODS OF // istream, ostream, AND iostream ARE AVAILABLE! // // Basic example: // // nsFilePath myPath("/Development/iotest.txt"); // // nsOutputFileStream testStream(myPath); // testStream << "Hello World" << endl; // // 4. Requires streams to be constructed using typesafe nsFilePath specifier // (not the notorious and bug prone const char*), namely nsFilePath. See // nsFileSpec.h for more details. // // 5. Fixes a bug that have been there for a long time, and // is inevitable if you use NSPR alone: // // The problem on platforms (Macintosh) in which a path does not fully // specify a file, because two volumes can have the same name. // // Not yet provided: // // Endian-awareness for reading and writing crossplatform binary files. At this // time there seems to be no demand for this. // //======================================================================================== #ifndef _FILESTREAM_H_ #define _FILESTREAM_H_ #include "nscore.h" #ifdef XP_MAC #include "pprio.h" // To get PR_ImportFile #else #include "prio.h" #endif #include "nsFileSpec.h" //======================================================================================== // Compiler-specific macros, as needed //======================================================================================== #if !defined(NS_USING_NAMESPACE) && (defined(__MWERKS__) || defined(XP_PC)) #define NS_USING_NAMESPACE #endif #if !defined(NS_USING_STL) && (defined(__MWERKS__) || defined(XP_PC)) #define NS_USING_STL #endif #ifdef NS_USING_NAMESPACE #define NS_NAMESPACE_PROTOTYPE #define NS_NAMESPACE namespace #define NS_NAMESPACE_END #else #define NS_NAMESPACE_PROTOTYPE static #define NS_NAMESPACE struct #define NS_NAMESPACE_END ; #endif // NS_USING_NAMESPACE #ifdef NS_USING_STL // Macintosh and Windows use this section. // // Here's where the party is. When Unix wants to join in (by supporting // a build system with STL headers), what fun we'll have! Meanwhile, I've used // macros to make this build on all our platforms. Unix doesn't have support for // STL, and therefore we could not use the template forms of these classes on Unix. // (it's a long story). Therefore, Unix supports no stream char types except 1-byte // characters, and therefore nobody else does now either, until Unix catches up. #define DEFINING_FILE_STREAM // templateers define this when this file is included. #define IOS_BASE ios_base #include using std::ios_base; using std::basic_streambuf; using std::codecvt_base; using std::codecvt; using std::streamsize; using std::locale; using std::basic_istream; using std::basic_ostream; using std::basic_iostream; using std::char_traits; #define TEMPLATE_DEF template #define FILE_BUFFER_TYPE nsFileBufferT #define INPUT_FILE_STREAM nsInputFileStreamT #define OUTPUT_FILE_STREAM nsOutputFileStreamT #define IO_FILE_STREAM nsIOFileStreamT #define BASIC_STREAMBUF basic_streambuf #define BASIC_ISTREAM basic_istream #define BASIC_OSTREAM basic_ostream #define BASIC_IOSTREAM basic_iostream #define INT_TYPE FILE_BUFFER_TYPE::int_type #define POS_TYPE FILE_BUFFER_TYPE::pos_type #define OFF_TYPE FILE_BUFFER_TYPE::off_type #define SEEK_DIR IOS_BASE::seekdir #define EOF_VALUE traits::eof() #else // Unix uses this section until it supports STL. This means no locales, no traits, // no wide chars, etc. Also, the stream classes are the original ARM-style ones, // and are not templatized. #define IOS_BASE ios #include #define TEMPLATE_DEF #define FILE_BUFFER_TYPE nsFileBufferT #define INPUT_FILE_STREAM nsInputFileStreamT #define OUTPUT_FILE_STREAM nsOutputFileStreamT #define IO_FILE_STREAM nsIOFileStreamT #define BASIC_STREAMBUF streambuf #define BASIC_ISTREAM istream #define BASIC_OSTREAM ostream #define BASIC_IOSTREAM iostream #define INT_TYPE int #define POS_TYPE long #define OFF_TYPE long #define SEEK_DIR ios::seek_dir #define int_type int #define pos_type long #define off_type long #define char_type char #define EOF_VALUE EOF #endif // NS_USING_STL #ifdef __MWERKS__ #ifdef MSIPL_WCHART #define NS_USING_WIDE_CHAR #endif #ifdef MSIPL_EXPLICIT_FUNC_TEMPLATE_ARG #define NS_EXPLICIT_FUNC_TEMPLATE_ARG #endif #define NS_READ_LOCK(mut) READ_LOCK(mut) #define NS_WRITE_LOCK(mut) WRITE_LOCK(mut) #else // Fix me, if necessary, for thread-safety. #define NS_READ_LOCK(mut) #define NS_WRITE_LOCK(mut) #endif // __MWERKS__ //=========================== End Compiler-specific macros =============================== //======================================================================================== NS_NAMESPACE nsFileStreamHelpers // Prototypes for common (non-template) implementations in the .cpp file which do not // need the template args (charT, traits). //======================================================================================== { NS_NAMESPACE_PROTOTYPE NS_BASE PRFileDesc* open( const nsFilePath& inFile, IOS_BASE::openmode mode, PRIntn accessMode); } NS_NAMESPACE_END // nsFileStreamHelpers //======================================================================================== // Template declarations //======================================================================================== //======================================================================================== TEMPLATE_DEF class nsFileBufferT //======================================================================================== : public BASIC_STREAMBUF { #ifdef NS_USING_STL typedef codecvt_base::result result; public: typedef charT char_type; typedef typename traits::pos_type pos_type; typedef typename traits::off_type off_type; typedef typename traits::int_type int_type; typedef traits traits_type; typedef typename traits::state_type state_type; typedef codecvt ofacet_type; typedef codecvt ifacet_type; #endif public: nsFileBufferT(); nsFileBufferT(PRFileDesc* pfile_arg); virtual ~nsFileBufferT(); bool is_open() const; FILE_BUFFER_TYPE* open( const nsFilePath& inFile, IOS_BASE::openmode mode, PRIntn accessMode); FILE_BUFFER_TYPE* close(); protected: virtual int_type overflow(int_type c=EOF_VALUE); virtual int_type pbackfail(int_type c=EOF_VALUE); virtual int_type underflow(); virtual pos_type seekoff( off_type off, SEEK_DIR way, IOS_BASE::openmode which=IOS_BASE::in|IOS_BASE::out); virtual pos_type seekpos(pos_type sp, IOS_BASE::openmode which=IOS_BASE::in|IOS_BASE::out); virtual BASIC_STREAMBUF* setbuf(char_type* s, streamsize n); virtual int sync(); virtual int_type uflow(); #ifdef NS_USING_STL virtual void imbue(const locale& loc); #endif virtual streamsize showmanyc(); virtual streamsize xsgetn(char_type* s, streamsize n); virtual streamsize xsputn(const char_type* s, streamsize n); private: PRFileDesc* mFileDesc; IOS_BASE::openmode mode_; }; // class nsFileBufferT //======================================================================================== TEMPLATE_DEF class nsInputFileStreamT //======================================================================================== : public BASIC_ISTREAM { #ifdef NS_USING_STL public: typedef charT char_type; typedef typename traits::pos_type pos_type; typedef typename traits::off_type off_type; typedef typename traits::int_type int_type; typedef traits traits_type; #endif public: nsInputFileStreamT(); explicit nsInputFileStreamT( const nsFilePath& inFile, IOS_BASE::openmode mode=IOS_BASE::in, PRIntn accessMode = 0x00400); virtual ~nsInputFileStreamT(); FILE_BUFFER_TYPE* rdbuf() const; inline bool is_open(); inline void open( const nsFilePath& inFile, IOS_BASE::openmode mode=IOS_BASE::in, PRIntn accessMode = 0x00400); inline void close(); private: FILE_BUFFER_TYPE mBuffer; }; // class nsInputFileStreamT //======================================================================================== TEMPLATE_DEF class nsOutputFileStreamT //======================================================================================== : public BASIC_OSTREAM { #ifdef NS_USING_STL public: typedef charT char_type; typedef typename traits::pos_type pos_type; typedef typename traits::off_type off_type; typedef typename traits::int_type int_type; typedef traits traits_type; #endif public: nsOutputFileStreamT(); explicit nsOutputFileStreamT( const nsFilePath& inFile, IOS_BASE::openmode mode = IOS_BASE::out|IOS_BASE::trunc, PRIntn accessMode = 0x00200); virtual ~nsOutputFileStreamT(); FILE_BUFFER_TYPE* rdbuf() const; inline bool is_open(); inline void open( const nsFilePath& inFile, IOS_BASE::openmode mode = IOS_BASE::out|IOS_BASE::trunc, PRIntn accessMode = 0x00200); inline void close(); private: FILE_BUFFER_TYPE mBuffer; }; // class nsOutputFileStreamT //======================================================================================== // Implementation of nsFileBufferT //======================================================================================== //---------------------------------------------------------------------------------------- TEMPLATE_DEF inline FILE_BUFFER_TYPE::nsFileBufferT() : BASIC_STREAMBUF(), mFileDesc(NULL) //---------------------------------------------------------------------------------------- { } //---------------------------------------------------------------------------------------- TEMPLATE_DEF inline FILE_BUFFER_TYPE::nsFileBufferT(PRFileDesc* pfarg) : BASIC_STREAMBUF(), mFileDesc(pfarg) //---------------------------------------------------------------------------------------- { } //---------------------------------------------------------------------------------------- TEMPLATE_DEF inline FILE_BUFFER_TYPE* FILE_BUFFER_TYPE::close() // Must precede the destructor because both are inline. //---------------------------------------------------------------------------------------- { if (mFileDesc==PR_STDIN || mFileDesc==PR_STDOUT || mFileDesc==PR_STDERR) return this; NS_WRITE_LOCK(_mutex); return (mFileDesc && PR_Close(mFileDesc) == PR_SUCCESS) ? mFileDesc = 0, this : 0; } #if defined(DEFINING_FILE_STREAM) //---------------------------------------------------------------------------------------- TEMPLATE_DEF FILE_BUFFER_TYPE::~nsFileBufferT() //---------------------------------------------------------------------------------------- { close(); } #endif // #if defined(DEFINING_FILE_STREAM) //---------------------------------------------------------------------------------------- TEMPLATE_DEF inline bool FILE_BUFFER_TYPE::is_open() const //---------------------------------------------------------------------------------------- { NS_READ_LOCK(_mutex); return bool(mFileDesc); // in case it is typedefed to int } //---------------------------------------------------------------------------------------- TEMPLATE_DEF inline FILE_BUFFER_TYPE* FILE_BUFFER_TYPE::open( const nsFilePath& inFile, IOS_BASE::openmode mode, PRIntn accessMode) //---------------------------------------------------------------------------------------- { if (mFileDesc) return 0; NS_WRITE_LOCK(_mutex); mFileDesc = nsFileStreamHelpers::open(inFile, mode, accessMode); if (!mFileDesc) return 0; mode_ = mode; return this; } // FILE_BUFFER_TYPE::open //---------------------------------------------------------------------------------------- TEMPLATE_DEF inline int FILE_BUFFER_TYPE:: sync() //---------------------------------------------------------------------------------------- { return (mFileDesc ? (int)PR_Sync(mFileDesc) : 0); } //---------------------------------------------------------------------------------------- TEMPLATE_DEF inline BASIC_STREAMBUF* FILE_BUFFER_TYPE::setbuf(char_type*, streamsize) //---------------------------------------------------------------------------------------- { return (!mFileDesc) ? 0 : this; } #if defined(DEFINING_FILE_STREAM) //---------------------------------------------------------------------------------------- TEMPLATE_DEF INT_TYPE FILE_BUFFER_TYPE::overflow(int_type c) //---------------------------------------------------------------------------------------- { #ifndef NS_USING_STL char ch = c; PRInt32 bytesWrit1 = PR_Write(mFileDesc, &ch, sizeof(ch)); return bytesWrit1 < sizeof(ch) ? EOF_VALUE : c; #else #ifdef NS_EXPLICIT_FUNC_TEMPLATE_ARG const ofacet_type& ft=use_facet(getloc()); #elif defined(XP_PC) const ofacet_type& ft=use_facet(getloc(), (ofacet_type*)0, false); #else const ofacet_type& ft=use_facet(getloc(), (ofacet_type*)0); #endif char_type ch = traits_type::to_char_type(c); if (!mFileDesc) return EOF_VALUE; if (traits_type::eq_int_type(c, EOF_VALUE)) return traits_type::not_eof(c); if (ft.always_noconv()) { PRInt32 bytesWrit1 = PR_Write(mFileDesc, &ch, sizeof(ch)); return bytesWrit1 < sizeof(ch) ? EOF_VALUE : c; } { // <- sic! state_type fst; const char_type* end; char buf[4]; char* ebuf; result conv; if ((conv=ft.out(fst, &ch, &ch+1, end, buf, buf+3, ebuf))== codecvt_base::noconv) { PRInt32 bytesWrit2 = PR_Write(mFileDesc, &ch, sizeof(ch)); return bytesWrit2 < sizeof(ch) ? EOF_VALUE : c; } if ((conv==codecvt_base::partial)||(conv==codecvt_base::error)) return EOF_VALUE; *ebuf=0; PRInt32 bytesWrit3 = strlen(buf); return PR_Write(mFileDesc, buf, bytesWrit3) < bytesWrit3 ? EOF_VALUE : c; } #endif } #endif // #if defined(DEFINING_FILE_STREAM) //---------------------------------------------------------------------------------------- TEMPLATE_DEF inline INT_TYPE FILE_BUFFER_TYPE::underflow() //---------------------------------------------------------------------------------------- { if (!mFileDesc) return EOF_VALUE; char_type s; PRInt32 request = 1; if (1 != PR_Read(mFileDesc, &s, request)) return EOF_VALUE; PR_Seek(mFileDesc, -1, PR_SEEK_CUR); return (int_type)s; } #if defined(DEFINING_FILE_STREAM) //---------------------------------------------------------------------------------------- TEMPLATE_DEF streamsize FILE_BUFFER_TYPE::xsputn(const char_type* s, streamsize n) //---------------------------------------------------------------------------------------- { #ifndef NS_USING_STL PRInt32 bytesWrit1 = PR_Write(mFileDesc, s, sizeof(char) * size_t(n)); return bytesWrit1 < 0 ? 0 : (streamsize)bytesWrit1; #else #ifdef NS_EXPLICIT_FUNC_TEMPLATE_ARG const ofacet_type& ft=use_facet(loc); #elif defined(XP_PC) const ofacet_type& ft=use_facet(getloc(), (ofacet_type*)0, false); #else const ofacet_type& ft=use_facet(getloc(), (ofacet_type*)0); #endif if (!mFileDesc || !n) return 0; if (ft.always_noconv()) { PRInt32 bytesWrit1 = PR_Write(mFileDesc, s, sizeof(char) * size_t(n)); return bytesWrit1 < 0 ? 0 : (streamsize)bytesWrit1; } { // <- sic! state_type fst; const char_type* end; char buf[8]; char* ebuf; result conv; #ifdef NS_EXPLICIT_FUNC_TEMPLATE_ARG if ((conv=use_facet(getloc()). #elif defined(XP_PC) if ((conv=use_facet(getloc(), (ofacet_type*)0, false). #else if ((conv=use_facet(getloc(), (ofacet_type*)0). #endif out(fst, s, s+n, end, buf, buf+7, ebuf))==codecvt_base::noconv) return (streamsize)PR_Write(mFileDesc, s, sizeof(char) * size_t(n)); if ((conv==codecvt_base::partial) ||(conv==codecvt_base::error)) return 0; *ebuf=0; PRInt32 bytesWrit2 = strlen(buf); bytesWrit2 = PR_Write(mFileDesc, buf, bytesWrit2); return bytesWrit2 < 0 ? 0 : streamsize(bytesWrit2 / sizeof(char_type)); } #endif } // FILE_BUFFER_TYPE::xsputn #endif // #if defined(DEFINING_FILE_STREAM) //---------------------------------------------------------------------------------------- TEMPLATE_DEF inline INT_TYPE FILE_BUFFER_TYPE::pbackfail(int_type c) //---------------------------------------------------------------------------------------- { if (!mFileDesc) return EOF_VALUE; if (PR_Seek(mFileDesc, -1, PR_SEEK_CUR) < 0) return EOF_VALUE; #ifdef NS_USING_STL return (traits::eq_int_type(c, EOF_VALUE)) ? traits::not_eof(c) : c; #else return c; #endif } //---------------------------------------------------------------------------------------- TEMPLATE_DEF inline INT_TYPE FILE_BUFFER_TYPE::uflow() //---------------------------------------------------------------------------------------- { if (!mFileDesc) return EOF_VALUE; char_type s; if (1 != PR_Read(mFileDesc, &s, 1)) // attempt to read 1 byte, confirm 1 byte return EOF_VALUE; return (int_type)s; } //---------------------------------------------------------------------------------------- TEMPLATE_DEF inline streamsize FILE_BUFFER_TYPE::xsgetn(char_type* s, streamsize n) //---------------------------------------------------------------------------------------- { return mFileDesc ? (streamsize)PR_Read(mFileDesc, s, sizeof(char) * size_t(n)) : 0; } #ifdef NS_USING_STL //---------------------------------------------------------------------------------------- TEMPLATE_DEF inline void FILE_BUFFER_TYPE::imbue(const locale& loc_arg) //---------------------------------------------------------------------------------------- { #ifdef XP_MAC loc = loc_arg; #endif } #endif //---------------------------------------------------------------------------------------- TEMPLATE_DEF inline streamsize FILE_BUFFER_TYPE::showmanyc() //---------------------------------------------------------------------------------------- { return (streamsize)PR_Available(mFileDesc); } #if defined(DEFINING_FILE_STREAM) //---------------------------------------------------------------------------------------- TEMPLATE_DEF POS_TYPE FILE_BUFFER_TYPE::seekoff( OFF_TYPE off, SEEK_DIR way, IOS_BASE::openmode /* which */) //---------------------------------------------------------------------------------------- { if (!mFileDesc || #ifdef NS_USING_STL ((way&IOS_BASE::beg) && off<0) || ((way&IOS_BASE::end) && off > 0) #else ((way == IOS_BASE::beg) && off<0) || ((way == IOS_BASE::end) && off > 0) #endif ) return pos_type(-1); PRSeekWhence poseek = PR_SEEK_CUR; switch (way) { case IOS_BASE::beg : poseek= PR_SEEK_SET; break; case IOS_BASE::end : poseek= PR_SEEK_END; break; } PRInt32 position = PR_Seek(mFileDesc, off, poseek); if (position < 0) return pos_type(-1); return pos_type(position); } #endif // #if defined(DEFINING_FILE_STREAM) #if defined(DEFINING_FILE_STREAM) //---------------------------------------------------------------------------------------- TEMPLATE_DEF POS_TYPE FILE_BUFFER_TYPE::seekpos(pos_type sp, IOS_BASE::openmode) //---------------------------------------------------------------------------------------- { if (!mFileDesc || sp==pos_type(-1)) return -1; #if defined(XP_PC) || defined(XP_UNIX) PRInt32 position = sp; #else PRInt32 position = sp.offset(); #endif position = PR_Seek(mFileDesc, position, PR_SEEK_SET); if (position < 0) return pos_type(-1); return position; } #endif // #if defined(DEFINING_FILE_STREAM) //======================================================================================== // Implementation of nsInputFileStreamT //======================================================================================== //---------------------------------------------------------------------------------------- TEMPLATE_DEF inline INPUT_FILE_STREAM::nsInputFileStreamT() : BASIC_ISTREAM(&mBuffer) //---------------------------------------------------------------------------------------- { // already inited } //---------------------------------------------------------------------------------------- TEMPLATE_DEF inline INPUT_FILE_STREAM::nsInputFileStreamT( const nsFilePath& inFile, IOS_BASE::openmode mode, PRIntn accessMode) //---------------------------------------------------------------------------------------- : BASIC_ISTREAM(&mBuffer) { // already inited if (!mBuffer.open(inFile, openmode(mode|in), accessMode)) setstate(failbit); } #if defined(DEFINING_FILE_STREAM) //---------------------------------------------------------------------------------------- TEMPLATE_DEF INPUT_FILE_STREAM::~nsInputFileStreamT() //---------------------------------------------------------------------------------------- { } #endif // #if defined(DEFINING_FILE_STREAM) //---------------------------------------------------------------------------------------- TEMPLATE_DEF inline FILE_BUFFER_TYPE* INPUT_FILE_STREAM::rdbuf() const //---------------------------------------------------------------------------------------- { return (FILE_BUFFER_TYPE*)&mBuffer; } //---------------------------------------------------------------------------------------- TEMPLATE_DEF inline bool INPUT_FILE_STREAM:: is_open() //---------------------------------------------------------------------------------------- { return mBuffer.is_open(); } //---------------------------------------------------------------------------------------- TEMPLATE_DEF inline void INPUT_FILE_STREAM::open( const nsFilePath& inFile, IOS_BASE::openmode mode, PRIntn accessMode) //---------------------------------------------------------------------------------------- { if (!mBuffer.open(inFile, openmode(mode|in), accessMode)) setstate(failbit); } //---------------------------------------------------------------------------------------- TEMPLATE_DEF inline void INPUT_FILE_STREAM::close() //---------------------------------------------------------------------------------------- { if (!mBuffer.close()) setstate(failbit); } //======================================================================================== // Implementation of nsOutputFileStreamT //======================================================================================== //---------------------------------------------------------------------------------------- TEMPLATE_DEF inline OUTPUT_FILE_STREAM::nsOutputFileStreamT() : BASIC_OSTREAM(&mBuffer) //---------------------------------------------------------------------------------------- { // already inited } #if defined(DEFINING_FILE_STREAM) //---------------------------------------------------------------------------------------- TEMPLATE_DEF OUTPUT_FILE_STREAM::nsOutputFileStreamT( const nsFilePath& inFile, IOS_BASE::openmode mode, PRIntn accessMode) //---------------------------------------------------------------------------------------- : BASIC_OSTREAM(&mBuffer) { // already inited if (!mBuffer.open(inFile, openmode(mode|out), accessMode)) setstate(failbit); } #endif // #if defined(DEFINING_FILE_STREAM) #if defined(DEFINING_FILE_STREAM) //---------------------------------------------------------------------------------------- TEMPLATE_DEF inline OUTPUT_FILE_STREAM::~nsOutputFileStreamT() //---------------------------------------------------------------------------------------- { } #endif // #if defined(DEFINING_FILE_STREAM) //---------------------------------------------------------------------------------------- TEMPLATE_DEF inline FILE_BUFFER_TYPE* OUTPUT_FILE_STREAM::rdbuf() const //---------------------------------------------------------------------------------------- { return (FILE_BUFFER_TYPE*)&mBuffer; } //---------------------------------------------------------------------------------------- TEMPLATE_DEF inline bool OUTPUT_FILE_STREAM:: is_open() //---------------------------------------------------------------------------------------- { return mBuffer.is_open(); } //---------------------------------------------------------------------------------------- TEMPLATE_DEF inline void OUTPUT_FILE_STREAM::open( const nsFilePath& inFile, IOS_BASE::openmode mode, PRIntn accessMode) //---------------------------------------------------------------------------------------- { if (!mBuffer.open(inFile, openmode(mode | out), accessMode)) setstate(failbit); } //---------------------------------------------------------------------------------------- TEMPLATE_DEF inline void OUTPUT_FILE_STREAM:: close() //---------------------------------------------------------------------------------------- { if (!mBuffer.close()) setstate(failbit); } //======================================================================================== TEMPLATE_DEF class nsIOFileStreamT : public BASIC_IOSTREAM //======================================================================================== { #ifdef NS_USING_STL public: typedef charT char_type; typedef typename traits::pos_type pos_type; typedef typename traits::off_type off_type; typedef typename traits::int_type int_type; typedef traits traits_type; #endif public: nsIOFileStreamT(); explicit nsIOFileStreamT( const nsFilePath& inFile, IOS_BASE::openmode mode = IOS_BASE::in|IOS_BASE::out, PRIntn accessMode = 0x00600); virtual ~nsIOFileStreamT(); FILE_BUFFER_TYPE* rdbuf() const; inline bool is_open(); inline void open( const nsFilePath& inFile, IOS_BASE::openmode mode = IOS_BASE::in|IOS_BASE::out, PRIntn accessMode = 0x00600); inline void close(); private: FILE_BUFFER_TYPE mBuffer; }; // class nsIOFileStreamT //======================================================================================== // Implementation of nsIOFileStream //======================================================================================== //---------------------------------------------------------------------------------------- TEMPLATE_DEF inline IO_FILE_STREAM::nsIOFileStreamT() //---------------------------------------------------------------------------------------- : mBuffer(), BASIC_IOSTREAM(&mBuffer) { // already inited } //---------------------------------------------------------------------------------------- TEMPLATE_DEF inline IO_FILE_STREAM::nsIOFileStreamT( const nsFilePath& inFile, IOS_BASE::openmode mode, PRIntn accessMode) //---------------------------------------------------------------------------------------- : mBuffer(), BASIC_IOSTREAM(&mBuffer) { // already inited if (!mBuffer.open(inFile, mode, accessMode)) setstate(failbit); } //---------------------------------------------------------------------------------------- TEMPLATE_DEF inline IO_FILE_STREAM::~nsIOFileStreamT() //---------------------------------------------------------------------------------------- { } //---------------------------------------------------------------------------------------- TEMPLATE_DEF inline FILE_BUFFER_TYPE* IO_FILE_STREAM::rdbuf() const //---------------------------------------------------------------------------------------- { return (FILE_BUFFER_TYPE*)&mBuffer; } //---------------------------------------------------------------------------------------- TEMPLATE_DEF inline bool IO_FILE_STREAM::is_open() //---------------------------------------------------------------------------------------- { return mBuffer.is_open(); } //---------------------------------------------------------------------------------------- TEMPLATE_DEF inline void IO_FILE_STREAM::open( const nsFilePath& inFile, IOS_BASE::openmode mode, PRIntn accessMode) //---------------------------------------------------------------------------------------- { if (!mBuffer.open(inFile, mode, accessMode)) setstate(failbit); } //---------------------------------------------------------------------------------------- TEMPLATE_DEF inline void IO_FILE_STREAM::close() //---------------------------------------------------------------------------------------- { if (!mBuffer.close()) setstate(failbit); } //======================================================================================== // Specializations of the stream templates //======================================================================================== #ifdef NS_USING_STL typedef nsFileBufferT > nsFileBuffer; typedef nsInputFileStreamT > nsInputFileStream; typedef nsOutputFileStreamT > nsOutputFileStream; typedef nsIOFileStreamT > nsIOFileStream; #ifdef NS_USING_WIDE_CHAR typedef nsFileBufferT > nsWideFileBuffer; typedef nsInputFileStreamT > nsWideInputFileStream; typedef nsOutputFileStreamT > nsWideOutputFileStream; typedef nsIOFileStreamT > nsWideIOFileStream; #endif // NS_USING_WIDE_CHAR #else typedef nsFileBufferT nsFileBuffer; typedef nsInputFileStreamT nsInputFileStream; typedef nsOutputFileStreamT nsOutputFileStream; typedef nsIOFileStreamT nsIOFileStream; #endif #endif /* _FILESTREAM_H_ */