|| || || || || ||

---

File.h

Go to the documentation of this file.

#ifndef Impala_Persistency_File_h
#define Impala_Persistency_File_h

#include "Persistency/FileSystem.h"
#include "Basis/Endian.h"

namespace Impala
{
namespace Persistency
{


class File
{
public:

    typedef Util::IOBuffer IOBuffer;

    File()
    {
        mPath = "";
        mFileSystem = 0;
        mIsWritable = false;
    }

    File(CString path)
    {
        mPath = path;
        mFileSystem = 0;
        mIsWritable = false;
    }

    File(CString path, FileSystem* fs, bool isWritable)
    {
        mPath = path;
        mFileSystem = fs;
        mIsWritable = isWritable;
    }

    bool
    Valid() const
    {
        return (!mPath.empty() && (mFileSystem != 0));
    }

    String
    GetPath() const
    {
        return mPath;
    }

    FileSystem*
    GetFileSystem() const
    {
        return mFileSystem;
    }

    bool
    IsWritable() const
    {
        return mIsWritable;
    }

    void
    CopyFrom(File srcFile)
    {
        IOBuffer* srcBuf = srcFile.GetReadBuffer();
        if (!srcBuf)
            return;
        IOBuffer* dstBuf = GetWriteBuffer();
        if (!dstBuf)
        {
            delete srcBuf;
            return;
        }
        int bufSize = Util::Channel::DATA_BUFFER_SIZE;
        char* buf = new char[bufSize];
        while (srcBuf->Available() > 0)
        {
            int nrRead = srcBuf->Read(buf, bufSize);
            dstBuf->Write(buf, nrRead);
        }
        delete buf;
        delete dstBuf;
        delete srcBuf;
    }

    void
    Delete()
    {
        if (! (Valid() && IsWritable()))
            return;
        mFileSystem->DeleteFile(mPath);
        mPath = "";
    }

    // Strings

    template<class BackInsertIterator>
    void
    ReadStrings(BackInsertIterator bi, bool skipEmptyAndComment = true)
    {
        IOBuffer* buf = GetReadBuffer();
        if (! (buf && buf->Valid()))
        {
            return;
        }

        while (buf->Available())
        {
            String line = buf->ReadLine();
            if (line[0] || !skipEmptyAndComment)
            {
                if ((line[0] != '#') || !skipEmptyAndComment)
                    *bi++ = line;
            }
        }
        delete buf;
    }

    void
    ReadStrings(std::vector<String>& stringList)
    {
        ReadStrings(std::back_inserter(stringList));
    }

    template <class Iterator>
    bool
    WriteStrings(Iterator begin, Iterator end)
    {
        IOBuffer* buf = GetWriteBuffer();
        if (! (buf && buf->Valid()))
        {
            return false;
        }
        for (Iterator it=begin ; it!=end ; it++)
        {
            String s = *it;
            buf->Puts(s);
        }
        delete buf;
        return true;
    }

    void
    WriteStrings(const std::vector<String>& stringList)
    {
        WriteStrings(stringList.begin(), stringList.end());
    }

    // Native types

    template<class BackInsertIterator>
    void
    ReadNative(BackInsertIterator bi, bool useMemoryBuffer = false)
    {
        typedef typename BackInsertIterator::container_type::value_type elem_type;

        IOBuffer* buf = (useMemoryBuffer) ? GetReadBuffer(true, "")
                                          : GetReadBuffer();
        if (! (buf && buf->Valid()))
            return;

        while (buf->Available() > 0)
        {
            elem_type d;
            buf->Read(&d, sizeof(d));
            EndianSwap(&d);
            *bi++ = d;
        }
        delete buf;
    }

    template <class Iterator>
    void
    WriteNative(Iterator begin, Iterator end)
    {
        typedef typename Iterator::value_type elem_type;

        IOBuffer* buf = GetWriteBuffer();
        for (Iterator it=begin ; it!=end ; it++)
        {
            elem_type d = *it;
            EndianSwap(&d);
            buf->Write(&d, sizeof(d));
        }
        delete buf;
    }

    // IOBuffers

    // Get a new IOBUffer, ownership lies with caller
    IOBuffer*
    GetReadBuffer()
    {
        if (!Valid())
        {
            ILOG_ERROR("Can't get read buffer for invalid file");
            return 0;
        }
        return mFileSystem->GetIOBuffer(GetPath(), true, false, "", 0, true);
    }

    // Get a new IOBUffer, ownership lies with caller
    IOBuffer*
    GetReadBuffer(bool useMemoryIfLocal, String useLocalFileIfRemote,
                  Int64 useLocalSizeIfRemote = 0,
                  bool useIOBufferChannel = false)
    {
        if (!Valid())
        {
            ILOG_ERROR("Can't get read buffer for invalid file");
            return 0;
        }
        return mFileSystem->GetIOBuffer(GetPath(), true, useMemoryIfLocal,
                                        useLocalFileIfRemote,
                                        useLocalSizeIfRemote,
                                        useIOBufferChannel);
    }

    // Get a new IOBUffer, ownership lies with caller
    IOBuffer*
    GetWriteBuffer()
    {
        if (!Valid())
        {
            ILOG_ERROR("Can't get write buffer for invalid file");
            return 0;
        }
        if (!IsWritable())
        {
            ILOG_ERROR("Can't get write buffer for non-writable file");
            return 0;
        }
        return mFileSystem->GetIOBuffer(GetPath(), false, false, "tmp", 0, true);
    }

    // Get a new IOBUffer, ownership lies with caller
    IOBuffer*
    GetWriteBuffer(bool useMemoryIfLocal, String useLocalFileIfRemote,
                   Int64 useLocalSizeIfRemote = 0,
                   bool useIOBufferChannel = false)
    {
        if (!Valid())
        {
            ILOG_ERROR("Can't get write buffer for invalid file");
            return 0;
        }
        if (!IsWritable())
        {
            ILOG_ERROR("Can't get write buffer for non-writable file");
            return 0;
        }
        return mFileSystem->GetIOBuffer(GetPath(), false, useMemoryIfLocal,
                                        useLocalFileIfRemote,
                                        useLocalSizeIfRemote,
                                        useIOBufferChannel);
    }

private:

    String      mPath;
    FileSystem* mFileSystem;
    bool        mIsWritable;

    ILOG_VAR_DEC;
};

ILOG_VAR_INIT(File, Impala.Persistency);

} // namespace Persistency
} // namespace Impala

#endif

---