std::filestream Klassenreferenz

#include <filestream.hpp>

Klassendiagramm für std::filestream:

Zusammengehörigkeiten von std::filestream:

Öffentliche Methoden
	filestream ()
	filestream (std::string file, filemode_t mode, bool binary)
	filestream (const filestream &fs)
virtual	~filestream ()
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 size_t	write (const void *data, size_t offset, size_t size)
virtual filestream &	reopen (filemode_t mode, bool binary)
virtual void	clear ()
virtual void	write (char c)
virtual char	read ()
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 ()
filestream &	operator= (const filestream &fs)
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 Methoden
	filestream (FILE *f, filemode_t mode, bool b)

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

filestream() [1/4]

std::filestream::filestream ( )

inline

{}

filestream() [2/4]

std::filestream::filestream	(	std::string	file,
		filemode_t	mode,
		bool	binary
	)

            : stream()
        {
            m_mode = mode;
            m_strFile = file;
            m_binary = a;
            m_canSeek = true;
            m_canRead = (mode == filemode::read);
            m_canWrite = (mode == filemode::write);
            
            m_fFile = auto_ptr<FILE>( (FILE*)(Sys::fOpen ( file.c_str() ,
                    filemodetostring(mode, a))) );
 
        }

filestream() [3/4]

std::filestream::filestream

(

const filestream &

fs

)

        : stream(fs)
    {
        m_fFile.reset(fs.m_fFile.get());
        m_mode = fs.m_mode;
        m_strFile = fs.m_strFile;
        m_binary = fs.m_binary;
    }

~filestream()

std::filestream::~filestream ( )

virtual

    {
        close();
    }

filestream() [4/4]

std::filestream::filestream ( FILE *  f, filemode_t  mode, bool  b  )

protected

    {
        m_fFile.reset(f);
        m_mode = mode;
        m_strFile = "IoFile";
        m_binary = b;
    }

Dokumentation der Elementfunktionen

canRead()

virtual bool std::stream::canRead ( )

inlinevirtualinherited

{ return m_canRead; }

canread()

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

static

                                            {
        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 )

static

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

clear()

void std::filestream::clear ( )

virtual

Erneute Implementation von std::stream.

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

close()

bool std::filestream::close ( )

virtual

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

filename()

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

inlinevirtual

{ return m_strFile; }

flush()

void std::filestream::flush ( )

virtual

Erneute Implementation von std::stream.

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

isbinary()

virtual bool std::filestream::isbinary ( )

inlinevirtual

{ return m_binary; }

iseof()

bool std::filestream::iseof ( )

virtual

Erneute Implementation von std::stream.

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

isfile()

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

static

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

    }

mode()

virtual filemode_t std::filestream::mode ( )

inlinevirtual

{ return m_mode;}

operator bool()

std::filestream::operator bool ( )

inline

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

operator=()

filestream & std::filestream::operator=

(

const filestream &

fs

)

    {
        m_fFile.reset(fs.m_fFile.get());
        m_mode = fs.m_mode;
        m_strFile = fs.m_strFile;
        m_binary = fs.m_binary;
    }

position()

long std::filestream::position ( )

virtual

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  )

virtual

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

virtual

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  )

virtual

    {
        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  )

virtual

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

virtual

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  )

virtual

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 )

virtual

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

protected

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

protected

m_mode

filemode_t std::filestream::m_mode

protected

m_strFile

std::string std::filestream::m_strFile

protected

---

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

• include/filestream.hpp
• src/filestream.cpp