std::outstream Klassenreferenz

Klassendiagramm für std::outstream:

Zusammengehörigkeiten von std::outstream:

Öffentliche Methoden
	outstream ()
virtual ofstream &	write (const char *str)
virtual ofstream &	write (std::string str)
virtual size_t	write (const void *data, size_t offset, size_t size)
virtual void	write (char c)
virtual ofstream &	writeline (const char *str)
virtual ofstream &	writeline (const std::string str)
virtual bool	close ()
virtual size_t	seek (size_t off, seek_t org)
virtual size_t	read (void *data, size_t offset, size_t size)
virtual char	read ()
virtual filestream &	reopen (filemode_t mode, bool binary)
virtual void	clear ()
virtual long	position ()
virtual long	size ()
virtual bool	iseof ()
virtual void	flush ()
virtual std::string	filename ()
virtual bool	isbinary ()
virtual filemode_t	mode ()
	operator bool ()
virtual bool	canRead ()
virtual bool	canSeek ()
virtual bool	canWrite ()

Öffentliche, statische Methoden
static bool	isfile (std::string file)
static bool	canread (std::string file)
static bool	canwrite (std::string file)

Geschützte Attribute
filemode_t	m_mode
auto_ptr< FILE >	m_fFile
std::string	m_strFile
bool	m_binary
bool	m_canRead
bool	m_canWrite
bool	m_canSeek

Ausführliche Beschreibung

Beschreibung der Konstruktoren und Destruktoren

outstream()

std::outstream::outstream ( )

inline

        : ofstream(stdout, false)
        {
             filestream::m_strFile = std::string(std::string("stdout"));
        }

Dokumentation der Elementfunktionen

canRead()

virtual bool std::stream::canRead ( )

inlinevirtualinherited

{ return m_canRead; }

canread()

bool std::filestream::canread ( std::string  file )

staticinherited

                                            {
        void* f = Sys::fOpen(file.c_str(), "r");
        if(f != 0)
        {
            Sys::fClose(f);
            return true;
        }
        return false;
    }

canSeek()

virtual bool std::stream::canSeek ( )

inlinevirtualinherited

{ return m_canSeek; }

canWrite()

virtual bool std::stream::canWrite ( )

inlinevirtualinherited

{ return m_canWrite; }

canwrite()

bool std::filestream::canwrite ( std::string  file )

staticinherited

                                             {
        void* f = Sys::fOpen(file.c_str(), "w");
        if(f != 0)
        {
            Sys::fClose(f);
            return true;
        }
        return false;
    }

clear()

void std::filestream::clear ( )

virtualinherited

Erneute Implementation von std::stream.

                           {
        if(m_fFile.get() !=0) {
            Sys::fSeek(m_fFile.get(), 0, SEEK_END);
        }
    }

close()

bool std::filestream::close ( )

virtualinherited

                            {
        if(m_fFile.get() !=0) {
            Sys::fClose(m_fFile.get());
            return true;
        }
        return false;
    }

filename()

virtual std::string std::filestream::filename ( )

inlinevirtualinherited

{ return m_strFile; }

flush()

void std::filestream::flush ( )

virtualinherited

Erneute Implementation von std::stream.

    {
        Sys::fFlush(m_fFile.get());
    }

isbinary()

virtual bool std::filestream::isbinary ( )

inlinevirtualinherited

{ return m_binary; }

iseof()

bool std::filestream::iseof ( )

virtualinherited

Erneute Implementation von std::stream.

    {
        return Sys::fEOF(m_fFile.get()); 
    }

isfile()

bool std::filestream::isfile ( std::string  file )

staticinherited

                                           {
        return Sys::fIsFile(file.c_str());

    }

mode()

virtual filemode_t std::filestream::mode ( )

inlinevirtualinherited

{ return m_mode;}

operator bool()

std::filestream::operator bool ( )

inlineinherited

{ return m_fFile.get() == 0; }

position()

long std::filestream::position ( )

virtualinherited

Erneute Implementation von std::stream.

    { 
        return Sys::fTell(m_fFile.get()); 
    } 

read() [1/2]

size_t std::filestream::read ( void *  data, size_t  offset, size_t  size  )

virtualinherited

Erneute Implementation von std::stream.

                                                                   {
        size_t s = EOF;
        if(m_fFile.get() != 0 ) {
            if(offset != 0) seek(offset, SeekOrigin::Current);
            s = Sys::fRead (data, 1, size, m_fFile.get());
        }
        return s;
    }

read() [2/2]

char std::filestream::read ( )

virtualinherited

Erneute Implementation von std::stream.

                           {
        if(m_fFile.get() == 0)
            return EOF;
        return Sys::fGetc(m_fFile.get());
    }

reopen()

filestream & std::filestream::reopen ( filemode_t  mode, bool  binary  )

virtualinherited

    {
        if(mode != m_mode || m_binary != binary)
        {
            m_mode = mode;
            m_binary = binary;
            //m_fFile.reset( freopen(m_strFile,filemodetostring(mode, binary), m_fFile.get()) );
        }
        return *this;
    }

seek()

size_t std::filestream::seek ( size_t  off, seek_t  org  )

virtualinherited

Erneute Implementation von std::stream.

                                                   {
        size_t s = EOF;
        if(m_fFile.get() != 0 && m_canSeek) {
            Sys::fSeek(m_fFile.get(), off, 
                    (int)org);
            s = Sys::fTell(m_fFile.get());
        }
        return s;
    }

size()

long std::filestream::size ( )

virtualinherited

Erneute Implementation von std::stream.

    {
        long pos = position();
        long size = seek(0, SeekOrigin::End);
        seek(pos, SeekOrigin::Beginn);
        return size;    
    }

write() [1/4]

size_t std::filestream::write ( const void *  data, size_t  offset, size_t  size  )

virtualinherited

Erneute Implementation von std::stream.

                                                                          {
        //fwrite (buffer , sizeof(char), sizeof(buffer), pFile);
        size_t s = EOF;
        if(m_fFile.get() != 0 && m_canWrite) {
             if(offset != 0) seek(offset, SeekOrigin::Current);
            s = Sys::fWrite (data, 1, size, m_fFile.get());
        }
        return s;
    }

write() [2/4]

void std::filestream::write ( char  c )

virtualinherited

Erneute Implementation von std::stream.

                                  {
        if(m_fFile.get() !=0) {
            Sys::fPutc (c, m_fFile.get());
        }
    }

write() [3/4]

virtual ofstream& std::ofstream::write ( const char *  str )

inlinevirtualinherited

                                                  { 
            if(m_fFile.get() !=0 ) 
                Sys::fPrintf(m_fFile.get(), str); 
        } 

write() [4/4]

virtual ofstream& std::ofstream::write ( std::string  str )

inlinevirtualinherited

                                                { 
            if(m_fFile.get() !=0 ) 
                Sys::fPrintf(m_fFile.get(), str.c_str()); 
        } 

writeline() [1/2]

virtual ofstream& std::ofstream::writeline ( const char *  str )

inlinevirtualinherited

                                                     {
            write(std::string(str) << "\n"); 
        }

writeline() [2/2]

virtual ofstream& std::ofstream::writeline ( const std::string  str )

inlinevirtualinherited

                                                         {
            std::string d = str;
            write(d << ("\n")); 
        }

Dokumentation der Datenelemente

m_binary

bool std::filestream::m_binary

protectedinherited

m_canRead

bool std::stream::m_canRead

protectedinherited

m_canSeek

bool std::stream::m_canSeek

protectedinherited

m_canWrite

bool std::stream::m_canWrite

protectedinherited

m_fFile

auto_ptr<FILE> std::filestream::m_fFile

protectedinherited

m_mode

filemode_t std::filestream::m_mode

protectedinherited

m_strFile

std::string std::filestream::m_strFile

protectedinherited

---

Die Dokumentation für diese Klasse wurde erzeugt aufgrund der Datei:

• src/iostream.cpp