tpie::stream_crtp< child_t > Class Template Reference

Public Types
enum	offset_type { beginning, end, current }
	Type describing how we should interpret the offset supplied to seek. More...

Public Member Functions
void	seek (stream_offset_type offset, offset_type whence=beginning)
	Moves the logical offset in the stream. More...
stream_size_type	offset () const throw ()
	Calculate the current offset in the stream. More...
bool	can_read () const throw ()
	Check if we can read an item with read(). More...
bool	can_read_back () const throw ()
	Check if we can read an item with read_back(). More...
stream_size_type	size () const throw ()
	Get the size of the file measured in items. More...

Protected Member Functions
void	initialize ()
void	update_block ()
	Fetch block from disk as indicated by m_nextBlock, writing old block to disk if needed. More...

Static Protected Member Functions
template<typename IT , typename Stream >
static void	read_array (Stream &stream, const IT &start, const IT &end)
	Reads several items from the stream. More...
template<typename IT , typename Stream >
static void	write_array (Stream &stream, const IT &start, const IT &end)
	Write several items to the stream. More...

Protected Attributes
memory_size_type	m_index
	Item index into the current block, or maxint if we don't have a block. More...
stream_size_type	m_nextBlock
	After a cross-block seek: Block index of next block, or maxint if the current block is good enough OR if we haven't read/written anything yet. More...
memory_size_type	m_nextIndex
	After a cross-block seek: Item index into next block. More...
stream_size_type	m_blockStartIndex
	The file-level item index of the first item in the current block. More...

Detailed Description

template<typename child_t>
class tpie::stream_crtp< child_t >

Definition at line 36 of file stream_crtp.h.

Member Enumeration Documentation

offset_type

template<typename child_t >

enum tpie::stream_crtp::offset_type

Type describing how we should interpret the offset supplied to seek.

Definition at line 39 of file stream_crtp.h.

                     {
        beginning,
        end,
        current
    };

Member Function Documentation

can_read()

template<typename child_t >

bool tpie::stream_crtp< child_t >::can_read ( ) const throw ( )

inline

Check if we can read an item with read().

This is logically equivalent to:

return offset() < size();

but it might be faster.

Returns

Whether or not we can read more items from the stream.

Definition at line 109 of file stream_crtp.h.

                                         {
        assert(self().get_file().is_open());
        if (m_index < self().get_block().size ) return true;
        return offset() < self().size();
    }

can_read_back()

template<typename child_t >

bool tpie::stream_crtp< child_t >::can_read_back ( ) const throw ( )

inline

Check if we can read an item with read_back().

Returns

Whether or not we can read an item with read_back().

Definition at line 120 of file stream_crtp.h.

                                              {
        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;
    }

offset()

template<typename child_t >

stream_size_type tpie::stream_crtp< child_t >::offset ( ) const throw ( )

inline

Calculate the current offset in the stream.

Returns

The current offset in the stream

Definition at line 91 of file stream_crtp.h.

                                                   {
        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();
    }

read_array()

template<typename child_t >

template<typename IT , typename Stream >

static void tpie::stream_crtp< child_t >::read_array ( Stream &  stream, const IT &  start, const IT &  end  )

inlinestaticprotected

Reads several items from the stream.

Implementation note: If your iterator type is efficiently copyable with std::copy, then this will also read efficiently from the internal TPIE buffer.

Template Parameters

IT	The type of Random Access Iterators used to supply the items.

Parameters

start	Iterator to the first spot to write to.
end	Iterator past the last spot to write to.

Exceptions

end_of_stream_exception

If there are not enough elements in the stream to fill all the spots between start and end.

Definition at line 166 of file stream_crtp.h.

                                                                                     {
        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;
        }
    }

seek()

template<typename child_t >

void tpie::stream_crtp< child_t >::seek ( stream_offset_type  offset, offset_type  whence = beginning  )

inline

Moves the logical offset in the stream.

Parameters

offset	Where to move the logical offset to.
whence	Move the offset relative to what.

Definition at line 51 of file stream_crtp.h.

                                                                              {
        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);
    }

size()

template<typename child_t >

stream_size_type tpie::stream_crtp< child_t >::size ( ) const throw ( )

inline

Get the size of the file measured in items.

Returns

The number of items in the file.

Definition at line 133 of file stream_crtp.h.

                                                 {
        // 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();
    }

update_block()

template<typename child_t >

void tpie::stream_crtp< child_t >::update_block ( )

protected

Fetch block from disk as indicated by m_nextBlock, writing old block to disk if needed.

Update m_block, m_index, m_nextBlock and m_nextIndex. If m_nextBlock is maxint, use next block is the one numbered m_block->number+1. m_index is updated with the value of m_nextIndex.

write_array()

template<typename child_t >

template<typename IT , typename Stream >

static void tpie::stream_crtp< child_t >::write_array ( Stream &  stream, const IT &  start, const IT &  end  )

inlinestaticprotected

Write several items to the stream.

Implementation note: If your iterator type is efficiently copyable with std::copy, then this will also write efficiently into the internal TPIE buffer.

Template Parameters

IT	The type of Random Access Iterators used to supply the items.

Parameters

start	Iterator to the first item to write.
end	Iterator past the last item to write.

Definition at line 212 of file stream_crtp.h.

                                                                                      {
        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;
        }
    }

Member Data Documentation

m_blockStartIndex

template<typename child_t >

stream_size_type tpie::stream_crtp< child_t >::m_blockStartIndex

protected

The file-level item index of the first item in the current block.

When m_block is not the null block, this should be equal to m_block->number * block_items().

Definition at line 256 of file stream_crtp.h.

m_index

template<typename child_t >

memory_size_type tpie::stream_crtp< child_t >::m_index

protected

Item index into the current block, or maxint if we don't have a block.

Definition at line 245 of file stream_crtp.h.

m_nextBlock

template<typename child_t >

stream_size_type tpie::stream_crtp< child_t >::m_nextBlock

protected

After a cross-block seek: Block index of next block, or maxint if the current block is good enough OR if we haven't read/written anything yet.

Definition at line 249 of file stream_crtp.h.

m_nextIndex

template<typename child_t >

memory_size_type tpie::stream_crtp< child_t >::m_nextIndex

protected

After a cross-block seek: Item index into next block.

Otherwise, maxint as with m_nextBlock.

Definition at line 252 of file stream_crtp.h.

---

The documentation for this class was generated from the following file:

• stream_crtp.h