file.h

Go to the documentation of this file.

// -*- mode: c++; tab-width: 4; indent-tabs-mode: t; c-file-style: "stroustrup"; -*-
// vi:set ts=4 sts=4 sw=4 noet :
// Copyright 2009, 2010, 2012, The TPIE development team
//
// This file is part of TPIE.
//
// TPIE is free software: you can redistribute it and/or modify it under
// the terms of the GNU Lesser General Public License as published by the
// Free Software Foundation, either version 3 of the License, or (at your
// option) any later version.
//
// TPIE is distributed in the hope that it will be useful, but WITHOUT ANY
// WARRANTY; without even the implied warranty of MERCHANTABILITY or
// FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public
// License for more details.
//
// You should have received a copy of the GNU Lesser General Public License
// along with TPIE.  If not, see <http://www.gnu.org/licenses/>
#ifndef _TPIE_FILE_H
#define _TPIE_FILE_H


#ifdef _MSC_VER
//Yes we know you do not support throw(stream_exception)
#pragma warning( disable: 4290 ) 
#endif //_MSC_VER

#include <limits>
#include <tpie/file_base.h>
namespace tpie {


#ifdef _MSC_VER
#pragma warning( disable: 4200 )
#endif //_MSC_VER

template <typename T>
class file: public file_base {
public:
    typedef T item_type;

    static inline memory_size_type memory_usage(bool includeDefaultFileAccessor=true) {
        memory_size_type x = sizeof(file);
        if (includeDefaultFileAccessor)
            x += default_file_accessor::memory_usage();
        return x;
    }

    file(double blockFactor=1.0,
         file_accessor::file_accessor * fileAccessor=NULL):
        file_base(sizeof(T), blockFactor, fileAccessor) {};

    class stream: public file_base::stream {
    public:
        typedef T item_type;
        typedef file file_type;
    private:
        typedef typename file::block_t block_t;
    public:
        inline static memory_size_type memory_usage(double blockFactor=1.0) {
            return sizeof(stream) + block_size(blockFactor) +  sizeof(block_t);
        }

        stream() {}

        stream(file_type & file, stream_size_type offset=0):
            file_base::stream(file, offset) {}


        inline item_type & read_mutable() {
            assert(get_file().is_open());
            if (m_index >= m_block->size) {
                update_block();
                if (offset() >= get_file().size()) {
                    throw end_of_stream_exception();
                }
            }
            return reinterpret_cast<T*>(m_block->data)[m_index++];
        }

        inline const item_type & read() {
            return read_mutable();
        }

        inline const item_type & read_back() {
            assert(get_file().is_open());
            seek(-1, current);
            const item_type & i = read();
            seek(-1, current);
            return i;
        }

        inline void write(const item_type& item) throw(stream_exception) {
            assert(get_file().is_open());
#ifndef NDEBUG
            if (!get_file().is_writable())
                throw io_exception("Cannot write to read only stream");
#endif
            if (m_index >= block_items()) update_block();
            reinterpret_cast<T*>(m_block->data)[m_index++] = item;
            write_update();
        }

        template <typename IT>
        inline void write(const IT & start, const IT & end) {
            assert(get_file().is_open());
            write_array(*this, start, end);
        }

        template <typename IT>
        inline void read(const IT & start, const IT & end) {
            assert(get_file().is_open());
            read_array(*this, start, end);
        }

        inline void attach(file & f) {
            attach_inner(f);
        }

        inline void detach() {
            detach_inner();
        }
    };
};
}
#endif //_TPIE_FILE_H