file_base.h

Go to the documentation of this file.

// -*- mode: c++; tab-width: 4; indent-tabs-mode: t; eval: (progn (c-set-style "stroustrup") (c-set-offset 'innamespace 0)); -*-
// vi:set ts=4 sts=4 sw=4 noet :
// Copyright 2009, 2011, 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_BASE_H__
#define __TPIE_FILE_BASE_H__
#include <tpie/file_base_crtp.h>
#include <tpie/stream_crtp.h>
#include <tpie/exception.h>
#include <tpie/file_accessor/file_accessor.h>
#ifndef WIN32
#include <tpie/file_accessor/posix.h>
#else 
#include <tpie/file_accessor/win32.h>
#endif //WIN32
#include <boost/intrusive/list.hpp>
#include <tpie/tempname.h>
#include <memory>
#include <tpie/memory.h>
#include <tpie/cache_hint.h>
#include <tpie/access_type.h>
#include <tpie/types.h>
#include <algorithm>

namespace tpie {

class file_base: public file_base_crtp<file_base> {
    typedef file_base_crtp<file_base> p_t;
protected:
#ifdef WIN32
#pragma warning( push )
#pragma warning( disable : 4200 )
#endif
    struct block_t : public boost::intrusive::list_base_hook<> {
        memory_size_type size;
        memory_size_type usage;
        stream_size_type number;
        bool dirty;
        char data[0];
    };
#ifdef WIN32
#pragma warning( pop )
#endif

    inline void update_size(stream_size_type size) {
        m_size = std::max(m_size, size);
        if (m_tempFile) 
            m_tempFile->update_recorded_size(m_fileAccessor->byte_size());
    }

public:
    inline stream_size_type size() const throw() {
        return file_size();
    }

    void close();

    class stream: public stream_crtp<stream> {
    private:
        typedef stream_crtp<stream> p_t;

        friend class stream_crtp<stream>;

        file_base * m_file;

    protected:
        block_t & get_block() {return *m_block;}
        const block_t & get_block() const {return *m_block;}
        inline file_base & get_file() {assert(m_file != 0); return *m_file;}
        inline const file_base & get_file() const {assert(m_file != 0); return *m_file;}

        void update_block_core();

        inline void update_vars() {}

        block_t * m_block;

    public:
        inline bool attached() const { return 0 != m_file; }

    protected:
        void attach_inner(file_base & f);

        void detach_inner();

    public:
        inline memory_size_type block_items() const {return get_file().m_blockItems;}

    protected:
        inline void write_update() {
            m_block->dirty = true;
            m_block->size = std::max(m_block->size, m_index);
            get_file().update_size(static_cast<stream_size_type>(m_index)+m_blockStartIndex);
        }

    public:
        stream(file_base & file, stream_size_type offset=0);

        stream() : m_file(0) {}

    private:
        void free();

    public:
        inline ~stream() {free();}


    protected:
        inline void initialize() {
            if (m_block != &get_file().m_emptyBlock) get_file().free_block(m_block);
            p_t::initialize();
            m_block = &get_file().m_emptyBlock;
        }
    };

    void truncate(stream_size_type s) throw(stream_exception) {
        assert(m_open);
        if (!m_used.empty()) {
            throw io_exception("Tried to truncate a file with one or more open streams");
        }
        m_size = s;
        m_fileAccessor->truncate(s);
        if (m_tempFile)
            m_tempFile->update_recorded_size(m_fileAccessor->byte_size());
    }

    ~file_base();


protected:
    file_base(memory_size_type item_size,
              double blockFactor=1.0,
              file_accessor::file_accessor * fileAccessor=NULL);

    void create_block();
    void delete_block();
    block_t * get_block(stream_size_type block);
    void free_block(block_t * block);


    static block_t m_emptyBlock;
    // TODO This should really be a hash map
    boost::intrusive::list<block_t> m_used;
    boost::intrusive::list<block_t> m_free;
};

} // namespace tpie

#endif //__TPIE_FILE_BASE_H__