std::ifstream Klassenreferenz

#include <iofstream.hpp>

Klassendiagramm für std::ifstream:

Zusammengehörigkeiten von std::ifstream:

Öffentliche Methoden
	ifstream ()
	ifstream (std::string file, bool binary)
	ifstream (FILE *file, bool binary)
virtual size_t	readline (void *data, size_t offset, size_t size)
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 size_t	write (const void *data, size_t offset, size_t size)
virtual void	write (char c)
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

ifstream() [1/3]

std::ifstream::ifstream ( )

inline

{}

ifstream() [2/3]

std::ifstream::ifstream ( std::string  file, bool  binary  )

inline

                : filestream(file, filemode::read, binary) { }

ifstream() [3/3]

std::ifstream::ifstream ( FILE *  file, bool  binary  )

inline

                : filestream(file, filemode::read, binary) { }

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());
    }

readline()

virtual size_t std::ifstream::readline ( void *  data, size_t  offset, size_t  size  )

inlinevirtual

                                                                         { 
            size_t r = 0, tobuf = 0; 
            char *buf = data, ch;
            
            for(;;) {
                r = read(&ch, offset, 1);
                if (r == -1) return -1;
                else if(r == 0) if (tobuf == 0) return 0; else break;
                else {
                    if (tobuf < size - 1) {
                        tobuf++;
                        *buf++ = ch;
                    }
                    if (ch == '\n')
                        break;
                }
            }
            *buf = '\0';
            return tobuf;
        } 

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/2]

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/2]

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

virtualinherited

Erneute Implementation von std::stream.

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

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:

• include/iofstream.hpp