stream_crtp.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 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_STREAM_CRTP_H__
#define __TPIE_STREAM_CRTP_H__
 
#include <tpie/tpie_export.h>
#include <tpie/types.h>
#include <tpie/exception.h>
#include <limits>
#include <cassert>
 
namespace tpie {
 
template <typename child_t>
class TPIE_EXPORT stream_crtp {
public:
    enum offset_type {
        beginning,
        end,
        current
    };
 
    inline void seek(stream_offset_type offset, offset_type whence=beginning) {
        assert(self().get_file().is_open());
        if (whence == end)
            offset += self().size();
        else if (whence == current) {
            // are we seeking into the current block?
            if (offset >= 0 || static_cast<stream_size_type>(-offset) <= m_index) {
                stream_size_type new_index = static_cast<stream_offset_type>(offset+m_index);
 
                if (new_index < self().get_file().block_items()) {
                    self().update_vars();
                    m_index = static_cast<memory_size_type>(new_index);
                    return;
                }
            }
 
            offset += self().offset();
        }
        if (0 > offset || (stream_size_type)offset > self().size())
            throw io_exception("Tried to seek out of file");
        self().update_vars();
        stream_size_type b = static_cast<stream_size_type>(offset) / self().get_file().block_items();
        m_index = static_cast<memory_size_type>(offset - b* self().get_file().block_items());
        if (b == self().get_block().number) {
            m_nextBlock = std::numeric_limits<stream_size_type>::max();
            m_nextIndex = std::numeric_limits<memory_size_type>::max();
            assert(self().offset() == (stream_size_type)offset);
            return;
        }
        m_nextBlock = b;
        m_nextIndex = m_index;
        m_index = std::numeric_limits<memory_size_type>::max();
        assert(self().offset() == (stream_size_type)offset);
    }
 
    inline stream_size_type offset() const throw() {
        assert(self().get_file().is_open());
        if (m_nextBlock == std::numeric_limits<stream_size_type>::max())
            return m_index + m_blockStartIndex;
        return m_nextIndex + m_nextBlock * self().get_file().block_items();
    }
 
    inline bool can_read() const throw() {
        assert(self().get_file().is_open());
        if (m_index < self().get_block().size ) return true;
        return offset() < self().size();
    }
 
    inline bool can_read_back() const throw() {
        assert(self().get_file().is_open());
        if (m_nextBlock == std::numeric_limits<stream_size_type>::max())
            return m_index > 0 || m_blockStartIndex > 0;
        else
            return m_nextIndex > 0 || m_nextBlock > 0;
    }
 
    inline stream_size_type size() const throw() {
        // XXX update_vars changes internal state in a way that is not visible
        // through the class interface.
        // therefore, a const_cast is warranted.
        const_cast<child_t&>(self()).update_vars();
        return self().get_file().file_size();
    }
 
protected:
    inline void initialize() {
        m_nextBlock = std::numeric_limits<stream_size_type>::max();
        m_nextIndex = std::numeric_limits<memory_size_type>::max();
        m_index = std::numeric_limits<memory_size_type>::max();
    }
 
    // Since this is called from file<T>::stream and file_stream<T>, we cannot
    // have the implementation in its own object.
    template <typename IT, typename Stream>
    static inline void read_array(Stream & stream, const IT & start, const IT & end) {
        typedef typename Stream::item_type T;
        IT i = start;
        while (i != end) {
            if (stream.m_index >= stream.block_items()) {
                // check to make sure we have enough items in the stream
                stream_size_type offs = stream.offset();
                if (offs >= stream.size()
                    || offs + (end-i) > stream.size()) {
 
                    throw end_of_stream_exception();
                }
 
                // fetch next block from disk
                stream.update_block();
            }
 
            T * src = reinterpret_cast<T*>(stream.get_block().data) + stream.m_index;
 
            // either read the rest of the block or until `end'
            memory_size_type count = std::min(stream.block_items()-stream.m_index, static_cast<memory_size_type>(end-i));
 
            std::copy(src, src + count, i);
 
            // advance output iterator
            i += count;
 
            // advance input position
            stream.m_index += count;
        }
    }
 
    // See read_array note above.
    template <typename IT, typename Stream>
    static inline void write_array(Stream & stream, const IT & start, const IT & end) {
        typedef typename Stream::item_type T;
        IT i = start;
        while (i != end) {
            if (stream.m_index >= stream.block_items()) stream.update_block();
 
            size_t streamRemaining = end - i;
            size_t blockRemaining = stream.block_items()-stream.m_index;
 
            IT till = (blockRemaining < streamRemaining) ? (i + blockRemaining) : end;
 
            T * dest = reinterpret_cast<T*>(stream.get_block().data) + stream.m_index;
 
            std::copy(i, till, dest);
 
            stream.m_index += till - i;
            stream.write_update();
            i = till;
        }
    }
 
    void update_block();
 
    memory_size_type m_index;
    stream_size_type m_nextBlock;
    memory_size_type m_nextIndex;
    stream_size_type m_blockStartIndex;
 
private:
    inline child_t & self() {return *static_cast<child_t*>(this);}
    inline const child_t & self() const {return *static_cast<const child_t*>(this);}
};
 
} // namespace tpie
 
#endif // __TPIE_STREAM_CRTP_H__