VFile.h

Go to the documentation of this file.

#ifndef __LDK_VFILE_H__
#define __LDK_VFILE_H__

//   Copyright (C) 2003-2006 Lorien Dunn.
//
//   Contact: loriendunn AT users DOT sourceforge DOT net
//
//   This software is provided 'as-is', without any express or implied warranty.
//   In no event will the authors be held liable for any damages arising from
//   the use of this software.
//
//   Permission is granted to anyone to use this software for any purpose,
//   including commercial applications, and to alter it and redistribute it
//   freely, subject to the following restrictions:
//
//   1. The origin of this software must not be misrepresented; you must not
//   claim that you wrote the original software. If you use this software in a
//   product, an acknowledgment in the product documentation would be
//   appreciated but is not required.
//
//   2. Altered source versions must be plainly marked as such, and must not be
//   misrepresented as being the original software.
//
//   3. This notice may not be removed or altered from any source distribution.
//



#include "LDK/String.h"
#include "LDK/SmartPointers.h"
#include "LDK/ByteOrder.h"
#include <stdarg.h>

#ifdef putc
#undef putc
#endif

#ifdef puts
#undef puts
#endif

#ifdef getc
#undef getc
#endif

namespace LDK
{
class LDK_API VFile : public Object
{
protected:
    bool mTextMode;
    bool mWriteable;
    String mName;
public:

    VFile() : mTextMode(true), mWriteable(false) {}

    virtual ~VFile() throw() {};

    inline const char* name() { return mName.c_str(); }

    virtual void openRead(const char* fileName, bool text=false)  = 0;

    virtual void openWrite(const char* fileName, bool text=false) = 0;

    virtual void openAppend(const char* fileName, bool text=false) = 0;

    virtual void close() = 0;

    virtual int64 length() = 0;

    virtual bool eof() = 0;

    virtual int64 tell() = 0;

    virtual int64 seek(int64 offset, int whence) = 0;

    virtual void flush() = 0;

    virtual int64 read(void *buffer, uint32 objCount, uint32 objSize=1) = 0;

    virtual int32 getc() = 0;

    virtual int32 ungetc(char c) = 0;

    virtual uint32 getString(char* buffer,uint32 size);

    virtual const char* gets(char* buffer, uint32 size) = 0;

    inline int16  readSLE16()
    {
        assert(!mTextMode);
        int16 dat = 0;
        this->read(&dat,1,2);
        return swapSLE16(dat);
    }

    inline uint16 readULE16()
    {
        assert(!mTextMode);
        uint16 dat = 0;
        this->read(&dat,1,2);
        return swapULE16(dat);
    }

    inline int16  readSBE16()
    {
        assert(!mTextMode);
        int16 dat = 0;
        this->read(&dat,1,2);
        return swapSBE16(dat);
    }

    inline uint16 readUBE16()
    {
        assert(!mTextMode);
        uint16 dat = 0;
        this->read(&dat,1,2);
        return swapUBE16(dat);
    }

    inline int32  readSLE32()
    {
        assert(!mTextMode);
        int32 dat = 0;
        this->read(&dat,1,4);
        return swapSLE32(dat);
    }

    inline uint32 readULE32()
    {
        assert(!mTextMode);
        uint32 dat = 0;
        this->read(&dat,1,4);
        return swapULE32(dat);
    }

    inline int32  readSBE32()
    {
        assert(!mTextMode);
        int32 dat = 0;
        this->read(&dat,1,4);
        return swapSBE32(dat);
    }

    inline uint32 readUBE32()
    {
        assert(!mTextMode);
        uint32 dat = 0;
        this->read(&dat,1,4);
        return swapUBE32(dat);
    }

    inline int64  readSLE64()
    {
        assert(!mTextMode);
        int64 dat = 0;
        this->read(&dat,1,8);
        return swapSLE64(dat);
    }

    inline uint64 readULE64()
    {
        assert(!mTextMode);
        uint64 dat = 0;
        this->read(&dat,1,8);
        return swapULE64(dat);
    }

    inline int64  readSBE64()
    {
        assert(!mTextMode);
        int64 dat = 0;
        this->read(&dat,1,8);
        return swapSBE64(dat);
    }

    inline uint64 readUBE64()
    {
        assert(!mTextMode);
        uint64 dat = 0;
        this->read(&dat,1,8);
        return swapUBE64(dat);
    }

    virtual int64 write(const void *buffer, uint32 objCount, uint32 objSize=1) = 0;

    virtual int32 putc(char c) = 0;

    virtual int32 puts(const char* str) = 0;

    virtual int32 printf(const char* format, ...) = 0;

    virtual int32 vprintf(const char *format, va_list ap) = 0;

    inline void writeSLE16(int16 dat)
    {
        assert(!mTextMode);
        dat = swapSLE16(dat);
        this->write(&dat,1,2);
    }

    inline void writeULE16(uint16 dat)
    {
        assert(!mTextMode);
        dat = swapULE16(dat);
        this->write(&dat,1,2);
    }

    inline void writeSBE16(int16 dat)
    {
        assert(!mTextMode);
        dat = swapSBE16(dat);
        this->write(&dat,1,2);
    }

    inline void writeUBE16(uint16 dat)
    {
        assert(!mTextMode);
        dat = swapUBE16(dat);
        this->write(&dat,1,2);
    }

    inline void writeSLE32(int32 dat)
    {
        assert(!mTextMode);
        dat = swapSLE32(dat);
        this->write(&dat,1,4);
    }

    inline void writeULE32(uint32 dat)
    {
        assert(!mTextMode);
        dat = swapULE32(dat);
        this->write(&dat,1,4);
    }

    inline void writeSBE32(int32 dat)
    {
        assert(!mTextMode);
        dat = swapSBE32(dat);
        this->write(&dat,1,4);
    }

    inline void writeUBE32(uint32 dat)
    {
        assert(!mTextMode);
        dat = swapUBE32(dat);
        this->write(&dat,1,4);
    }

    inline void writeSLE64(int64 dat)
    {
        assert(!mTextMode);
        dat = swapSLE64(dat);
        this->write(&dat,1,8);
    }

    inline void writeULE64(uint64 dat)
    {
        assert(!mTextMode);
        dat = swapULE64(dat);
        this->write(&dat,1,8);
    }

    inline void writeSBE64(int64 dat)
    {
        assert(!mTextMode);
        dat = swapSBE64(dat);
        this->write(&dat,1,8);
    }

    inline void writeUBE64(uint64 dat)
    {
        assert(!mTextMode);
        dat = swapUBE64(dat);
        this->write(&dat,1,8);
    }

    inline bool writeable() { return mWriteable; }
};

typedef IntrusiveSmartPointer<VFile> SmartFile;

}//namespace LDK

#endif //__LDK_VFILE_H__

---