MemFile Class Reference
[File handling]

Implements a memory file. More...

#include <MemFile.h>

Inheritance diagram for MemFile:

[legend]

Collaboration diagram for MemFile:

[legend]

List of all members.

Public Member Functions
	MemFile ()
	MemFile (const std::string &path)
	~MemFile ()
bool	fopen (const std::string &path, const std::string &mode)
void	fclose () const
size_t	fread (char *ptr, size_t size, size_t nmemb) const
size_t	fwrite (const char *ptr, size_t size, size_t nmemb)
char *	fgets (char *s, int size) const
void	fprintf (const char *format,...)
off_t	size () const
bool	eof () const
void	reset_read () const
void	reset_write ()
Private Member Functions
	MemFile (const MemFile &)
MemFile &	operator= (const MemFile &)
Private Attributes
std::string	m_path
bool	m_temporary
block_t *	m_base
block_t *	m_current_read
block_t *	m_current_write
int	m_current_write_nr
size_t	m_read_ptr
size_t	m_write_ptr
bool	m_b_read_caused_eof
Static Private Attributes
static std::map< std::string, block_t * >	m_files
Classes
struct	block_t
	File block structure. More...

---

Detailed Description

Implements a memory file.

Definition at line 46 of file MemFile.h.

---

Constructor & Destructor Documentation

MemFile::MemFile

(

)

Definition at line 48 of file MemFile.cpp.

:m_temporary(true)
,m_base(new block_t)
,m_current_read(m_base)
,m_current_write(m_base)
,m_current_write_nr(0)
,m_read_ptr(0)
,m_write_ptr(0)
,m_b_read_caused_eof(false)
{
}

MemFile::MemFile

(

const std::string &

path

)

Definition at line 61 of file MemFile.cpp.

References m_base, m_current_read, m_current_write, and m_files.

:m_path(path)
,m_temporary(false)
,m_base(m_files[path])
,m_current_read(NULL)
,m_current_write(NULL)
,m_current_write_nr(0)
,m_read_ptr(0)
,m_write_ptr(0)
,m_b_read_caused_eof(false)
{
        if (!m_base)
        {
                m_base = new block_t;
                m_files[path] = m_base;
        }
        m_current_read = m_base;
        m_current_write = m_base;
}

MemFile::~MemFile

(

)

Definition at line 82 of file MemFile.cpp.

References m_base, and m_temporary.

{
        while (m_base && m_temporary)
        {
                block_t *p = m_base;
                m_base = p -> next;
                delete p;
        }
}

MemFile::MemFile

(

const MemFile &

)

[inline, private]

Definition at line 77 of file MemFile.h.

{} // copy constructor

---

Member Function Documentation

bool MemFile::fopen	(	const std::string &	path,
		const std::string &	mode
	)			[virtual]

Implements IFile.

Definition at line 93 of file MemFile.cpp.

{
        return true;
}

void MemFile::fclose

(

)

const [virtual]

Implements IFile.

Definition at line 99 of file MemFile.cpp.

{
}

size_t MemFile::fread	(	char *	ptr,
		size_t	size,
		size_t	nmemb
	)			const [virtual]

Implements IFile.

Definition at line 104 of file MemFile.cpp.

References BLOCKSIZE, m_b_read_caused_eof, m_current_read, m_read_ptr, and m_write_ptr.

Referenced by fgets().

{
        size_t p = m_read_ptr % BLOCKSIZE;
        size_t sz = size * nmemb;
        size_t available = m_write_ptr - m_read_ptr;
        if (sz > available) // read beyond eof
        {
                sz = available;
                m_b_read_caused_eof = true;
        }
        if (!sz)
        {
                return 0;
        }
        if (p + sz < BLOCKSIZE)
        {
                memcpy(ptr, m_current_read -> data + p, sz);
                m_read_ptr += sz;
        }
        else
        {
                size_t sz1 = BLOCKSIZE - p;
                size_t sz2 = sz - sz1;
                memcpy(ptr, m_current_read -> data + p, sz1);
                m_read_ptr += sz1;
                while (sz2 > BLOCKSIZE)
                {
                        if (m_current_read -> next)
                        {
                                m_current_read = m_current_read -> next;
                                memcpy(ptr + sz1, m_current_read -> data, BLOCKSIZE);
                                m_read_ptr += BLOCKSIZE;
                                sz1 += BLOCKSIZE;
                                sz2 -= BLOCKSIZE;
                        }
                        else
                        {
                                return sz1;
                        }
                }
                if (m_current_read -> next)
                {
                        m_current_read = m_current_read -> next;
                        memcpy(ptr + sz1, m_current_read -> data, sz2);
                        m_read_ptr += sz2;
                }
                else
                {
                        return sz1;
                }
        }
        return sz;
}

size_t MemFile::fwrite	(	const char *	ptr,
		size_t	size,
		size_t	nmemb
	)			[virtual]

Implements IFile.

Definition at line 159 of file MemFile.cpp.

References BLOCKSIZE, m_current_write, m_current_write_nr, and m_write_ptr.

Referenced by fprintf().

{
        size_t p = m_write_ptr % BLOCKSIZE;
        int nr = (int)m_write_ptr / BLOCKSIZE;
        size_t sz = size * nmemb;
        if (m_current_write_nr < nr)
        {
                block_t *next = new block_t;
                m_current_write -> next = next;
                m_current_write = next;
                m_current_write_nr++;
        }
        if (p + sz <= BLOCKSIZE)
        {
                memcpy(m_current_write -> data + p, ptr, sz);
                m_write_ptr += sz;
        }
        else
        {
                size_t sz1 = BLOCKSIZE - p; // size left
                size_t sz2 = sz - sz1;
                memcpy(m_current_write -> data + p, ptr, sz1);
                m_write_ptr += sz1;
                while (sz2 > BLOCKSIZE)
                {
                        if (m_current_write -> next)
                        {
                                m_current_write = m_current_write -> next;
                                m_current_write_nr++;
                        }
                        else
                        {
                                block_t *next = new block_t;
                                m_current_write -> next = next;
                                m_current_write = next;
                                m_current_write_nr++;
                        }
                        memcpy(m_current_write -> data, ptr + sz1, BLOCKSIZE);
                        m_write_ptr += BLOCKSIZE;
                        sz1 += BLOCKSIZE;
                        sz2 -= BLOCKSIZE;
                }
                if (m_current_write -> next)
                {
                        m_current_write = m_current_write -> next;
                        m_current_write_nr++;
                }
                else
                {
                        block_t *next = new block_t;
                        m_current_write -> next = next;
                        m_current_write = next;
                        m_current_write_nr++;
                }
                memcpy(m_current_write -> data, ptr + sz1, sz2);
                m_write_ptr += sz2;
        }
        return sz;
}

char * MemFile::fgets	(	char *	s,
		int	size
	)			const [virtual]

Implements IFile.

Definition at line 221 of file MemFile.cpp.

References eof(), and fread().

{
        int n = 0;
        while (n < size - 1 && !eof())
        {
                char c;
                size_t sz = fread(&c, 1, 1);
                if (sz)
                {
                        if (c == 10)
                        {
                                s[n] = 0;
                                return s;
                        }
                        s[n++] = c;
                }
        }
        s[n] = 0;
        return s;
}

void MemFile::fprintf	(	const char *	format,
			...
	)			[virtual]

Implements IFile.

Definition at line 243 of file MemFile.cpp.

References BLOCKSIZE, and fwrite().

{
        va_list ap;
        char tmp[BLOCKSIZE];
        va_start(ap, format);
#ifdef _WIN32
        vsprintf(tmp, format, ap);
#else
        vsnprintf(tmp, BLOCKSIZE - 1, format, ap);
#endif
        va_end(ap);
        fwrite(tmp, 1, strlen(tmp));
}

off_t MemFile::size

(

)

const [virtual]

Implements IFile.

Definition at line 258 of file MemFile.cpp.

References m_write_ptr.

{
        return (off_t)m_write_ptr;
}

bool MemFile::eof

(

)

const [virtual]

Implements IFile.

Definition at line 264 of file MemFile.cpp.

References m_b_read_caused_eof.

Referenced by fgets().

{
        return m_b_read_caused_eof; //(m_read_ptr < m_write_ptr) ? false : true;
}

void MemFile::reset_read

(

)

const [virtual]

Implements IFile.

Definition at line 270 of file MemFile.cpp.

References m_base, m_current_read, and m_read_ptr.

{
        m_read_ptr = 0;
        m_current_read = m_base;
}

void MemFile::reset_write

(

)

[virtual]

Implements IFile.

Definition at line 277 of file MemFile.cpp.

References m_base, m_current_write, m_current_write_nr, and m_write_ptr.

{
        m_write_ptr = 0;
        m_current_write = m_base;
        m_current_write_nr = 0;
}

MemFile& MemFile::operator=

(

const MemFile &

)

[inline, private]

Definition at line 78 of file MemFile.h.

{ return *this; } // assignment operator

---

Member Data Documentation

std::map< std::string, MemFile::block_t * > MemFile::m_files [static, private]

Definition at line 80 of file MemFile.h.

Referenced by MemFile().

std::string MemFile::m_path [private]

Definition at line 81 of file MemFile.h.

bool MemFile::m_temporary [private]

Definition at line 82 of file MemFile.h.

Referenced by ~MemFile().

block_t* MemFile::m_base [private]

Definition at line 83 of file MemFile.h.

Referenced by MemFile(), reset_read(), reset_write(), and ~MemFile().

block_t* MemFile::m_current_read [mutable, private]

Definition at line 84 of file MemFile.h.

Referenced by fread(), MemFile(), and reset_read().

block_t* MemFile::m_current_write [private]

Definition at line 85 of file MemFile.h.

Referenced by fwrite(), MemFile(), and reset_write().

int MemFile::m_current_write_nr [private]

Definition at line 86 of file MemFile.h.

Referenced by fwrite(), and reset_write().

size_t MemFile::m_read_ptr [mutable, private]

Definition at line 87 of file MemFile.h.

Referenced by fread(), and reset_read().

size_t MemFile::m_write_ptr [private]

Definition at line 88 of file MemFile.h.

Referenced by fread(), fwrite(), reset_write(), and size().

bool MemFile::m_b_read_caused_eof [mutable, private]

Definition at line 89 of file MemFile.h.

Referenced by eof(), and fread().

---

The documentation for this class was generated from the following files:

• MemFile.h
• MemFile.cpp