tpie::uncompressed_stream< T > Class Template Reference

Simple class acting both as file and a file::stream. More...

#include <tpie/uncompressed_stream.h>

Inherits tpie::file_stream_base.

Public Types
typedef T	item_type
	The type of the items stored in the stream. More...
typedef file_base_crtp < file_stream_base >	p_t
typedef stream_crtp < file_stream_base >	s_t
enum	offset_type
	Type describing how we should interpret the offset supplied to seek. More...

Public Member Functions
	uncompressed_stream (double blockFactor=1.0, file_accessor::file_accessor *fileAccessor=NULL)
	Construct a new uncompressed_stream. More...
void	write (const item_type &item) throw (stream_exception)
	Write an item to the stream. More...
template<typename IT >
void	write (const IT &start, const IT &end) throw (stream_exception)
	Write several items to the stream. More...
const item_type &	read () throw (stream_exception)
	Read an item from the stream. More...
template<typename IT >
void	read (const IT &start, const IT &end) throw (stream_exception)
	Reads several items from the stream. More...
const item_type &	read_back () throw (stream_exception)
	Read an item from the stream. More...
const item_type &	peek ()
	Get next item from stream without advancing the position. More...
void	skip ()
	Advance the stream position to the next item. More...
void	skip_back ()
	Advance the stream position to the previous item. More...
void	swap (uncompressed_stream< T > &other)
void	close () throw (stream_exception)
	Close the file and release resources. More...
void	truncate (stream_size_type size)
	Truncate file to given size. More...
bool	is_readable () const throw ()
	Check if we can read from the file. More...
bool	is_writable () const throw ()
	Check if we can write to the file. More...
memory_size_type	block_size () const
	Get the size of a block in bytes. More...
memory_size_type	block_items () const
	Get the number of items per block. More...
template<typename TT >
void	read_user_data (TT &data) throw (stream_exception)
	Read the user data associated with the file. More...
memory_size_type	read_user_data (void *data, memory_size_type count)
	Read variable length user data associated with the file. More...
template<typename TT >
void	write_user_data (const TT &data) throw (stream_exception)
	Write user data to the stream. More...
void	write_user_data (const void *data, memory_size_type count)
	Write variable length user data associated with the file. More...
memory_size_type	user_data_size () const
	Get current user data size. More...
memory_size_type	max_user_data_size () const
	Get maximum user data size. More...
const std::string &	path () const throw ()
	The path of the file opened or the empty string. More...
void	open (const std::string &path, access_type accessType=access_read_write, memory_size_type userDataSize=0, cache_hint cacheHint=access_sequential) throw (stream_exception)
	Open a file. More...
void	open (memory_size_type userDataSize=0, cache_hint cacheHint=access_sequential) throw (stream_exception)
	Open an anonymous temporary file. More...
void	open (temp_file &file, access_type accessType=access_read_write, memory_size_type userDataSize=0, cache_hint cacheHint=access_sequential) throw (stream_exception)
	Open a temporary file. More...
bool	is_open () const
	Check if file is open. More...
stream_size_type	file_size () const throw ()
	Get the size of the file measured in items. More...
void	seek (stream_offset_type offset, offset_type whence=beginning) throw (stream_exception)
	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...

Static Public Member Functions
static memory_size_type	memory_usage (float blockFactor=1.0, bool includeDefaultFileAccessor=true) throw ()
	Calculate the amount of memory used by a single uncompressed_stream. More...
static memory_size_type	block_size (double blockFactor) throw ()
	Calculate the block size in bytes used by a stream. More...
static double	calculate_block_factor (memory_size_type blockSize) throw ()
	Find the block factor that would result in the given block size measured in bytes. More...
static memory_size_type	block_memory_usage (double blockFactor)
	Amount of memory used by a single block given the block factor. More...

Protected Member Functions
void	swap (file_stream_base &other)
void	open_inner (const std::string &path, access_type accessType, memory_size_type userDataSize, cache_hint cacheHint) throw (stream_exception)
void	get_block (stream_size_type block)
	Use file_accessor to fetch indicated block number into m_block. More...
void	flush_block ()
	Write block to disk. More...
void	update_vars ()
void	initialize ()
void	write_update ()
template<typename BT >
void	read_block (BT &b, stream_size_type block)
void	get_block_check (stream_size_type block)
void	update_block ()
	Fetch block from disk as indicated by m_nextBlock, writing old block to disk if needed. More...

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

Protected Attributes
block_t	m_block
memory_size_type	m_blockItems
memory_size_type	m_blockSize
bool	m_canRead
bool	m_canWrite
bool	m_open
memory_size_type	m_itemSize
file_accessor::file_accessor *	m_fileAccessor
tpie::unique_ptr< temp_file >	m_ownedTempFile
temp_file *	m_tempFile
stream_size_type	m_size
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...

Friends
struct	stream_item_array_operations

Detailed Description

template<typename T>
class tpie::uncompressed_stream< T >

Simple class acting both as file and a file::stream.

A uncompressed_stream basically supports every operation a file or a file::stream supports. This is used to access a file I/O-efficiently, and is the direct replacement of the old ami::stream.

Template Parameters

T	The type of items stored in the stream.

Definition at line 44 of file uncompressed_stream.h.

Member Typedef Documentation

template<typename T>

typedef T tpie::uncompressed_stream< T >::item_type

The type of the items stored in the stream.

Definition at line 47 of file uncompressed_stream.h.

Member Enumeration Documentation

enum tpie::stream_crtp::offset_type

inherited

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

Definition at line 38 of file stream_crtp.h.

                     {
        beginning,
        end,
        current
    };

Constructor & Destructor Documentation

template<typename T>

tpie::uncompressed_stream< T >::uncompressed_stream ( double  blockFactor = 1.0, file_accessor::file_accessor *  fileAccessor = NULL  )

inline

Construct a new uncompressed_stream.

Parameters

blockFactor	The relative size of a block compared to the default. To find the block factor corresponding to an absolute block size, use file_base::calculate_block_factor.
fileAccessor	The file accessor to use, if none is supplied a default will be used.

Definition at line 54 of file uncompressed_stream.h.

Referenced by tpie::uncompressed_stream< T >::memory_usage().

                                                                      :
        file_stream_base(sizeof(item_type), blockFactor, fileAccessor) {};

Member Function Documentation

template<typename child_t>

memory_size_type tpie::file_base_crtp< child_t >::block_items ( ) const

inlineinherited

Get the number of items per block.

Definition at line 105 of file file_base_crtp.h.

                                         {
        return m_blockItems;
    }

template<typename child_t>

static memory_size_type tpie::file_base_crtp< child_t >::block_memory_usage ( double  blockFactor )

inlinestaticinherited

Amount of memory used by a single block given the block factor.

Definition at line 98 of file file_base_crtp.h.

Referenced by tpie::uncompressed_stream< T >::memory_usage().

                                                                          {
        return block_size(blockFactor);
    }

template<typename child_t>

static memory_size_type tpie::file_base_crtp< child_t >::block_size ( double  blockFactor ) throw ( )

inlinestaticinherited

Calculate the block size in bytes used by a stream.

We have block_size(calculate_block_factor(b)) ~= b.

Parameters

blockFactor

Factor of the global block size to use.

Returns

Size in bytes.

Definition at line 78 of file file_base_crtp.h.

                                                                           {
        return static_cast<memory_size_type>(get_block_size() * blockFactor);
    }

template<typename child_t>

memory_size_type tpie::file_base_crtp< child_t >::block_size ( ) const

inlineinherited

Get the size of a block in bytes.

Definition at line 112 of file file_base_crtp.h.

Referenced by tpie::file_base_crtp< file_stream_base >::block_memory_usage(), and tpie::file_base_crtp< file_stream_base >::calculate_block_factor().

                                        {
        return m_blockSize;
    }

template<typename child_t>

static double tpie::file_base_crtp< child_t >::calculate_block_factor ( memory_size_type  blockSize ) throw ( )

inlinestaticinherited

Find the block factor that would result in the given block size measured in bytes.

We have calculate_block_factor(block_size(f)) ~= f.

Parameters

blockSize

The sought block size.

Returns

The block factor needed to achieve this block size.

Definition at line 91 of file file_base_crtp.h.

                                                                                     {
        return (double)blockSize / (double)block_size(1.0);
    }

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

inlineinherited

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 108 of file stream_crtp.h.

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

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

inlineinherited

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

void tpie::file_stream_base::close ( ) throw ( stream_exception )

inlineinherited

Close the file and release resources.

This will close the file and resources used by buffers and such.

Definition at line 51 of file file_stream_base.h.

References tpie::file_base_crtp< file_stream_base >::close(), tpie::file_stream_base::flush_block(), and tpie::tpie_delete_array().

                                                {
        if (m_open) flush_block();
        tpie_delete_array(m_block.data, m_itemSize * m_blockItems);
        m_block.data = 0;
        p_t::close();
    }

template<typename child_t>

stream_size_type tpie::file_base_crtp< child_t >::file_size ( ) const throw ( )

inlineinherited

Get the size of the file measured in items.

If there are streams of this file that have extended the stream length but have not yet flushed these writes, we might report an incorrect size.

Returns

The number of items in the file.

Definition at line 268 of file file_base_crtp.h.

                                                      {
        return m_size;
    }

void tpie::file_stream_base::flush_block ( )

inlineprotectedinherited

Write block to disk.

Definition at line 139 of file file_stream_base.h.

References tpie::file_accessor::stream_accessor_base< file_accessor_t >::byte_size(), and tpie::file_accessor::stream_accessor_base< file_accessor_t >::write_block().

Referenced by tpie::file_stream_base::close(), and tpie::file_stream_base::truncate().

                              {
        if (m_block.dirty) {
            assert(m_canWrite);
            update_vars();
            m_fileAccessor->write_block(m_block.data, m_block.number, m_block.size);
            if (m_tempFile)
                m_tempFile->update_recorded_size(m_fileAccessor->byte_size());
        }
        m_block.dirty = false;
    }

void tpie::file_stream_base::get_block ( stream_size_type  block )

protectedinherited

Use file_accessor to fetch indicated block number into m_block.

template<typename child_t>

bool tpie::file_base_crtp< child_t >::is_open ( ) const

inlineinherited

Check if file is open.

Definition at line 256 of file file_base_crtp.h.

                                {
        return m_open;
    }

template<typename child_t>

bool tpie::file_base_crtp< child_t >::is_readable ( ) const throw ( )

inlineinherited

Check if we can read from the file.

Returns

True if we can read from the file.

Definition at line 56 of file file_base_crtp.h.

                                     {
        return m_canRead;
    }

template<typename child_t>

bool tpie::file_base_crtp< child_t >::is_writable ( ) const throw ( )

inlineinherited

Check if we can write to the file.

Returns

True if we can write to the file.

Definition at line 65 of file file_base_crtp.h.

Referenced by tpie::uncompressed_stream< T >::write().

                                     {
        return m_canWrite;
    }

template<typename child_t>

memory_size_type tpie::file_base_crtp< child_t >::max_user_data_size ( ) const

inlineinherited

Get maximum user data size.

Definition at line 183 of file file_base_crtp.h.

Referenced by tpie::file_base_crtp< file_stream_base >::write_user_data().

                                                {
        assert(m_open);
        return m_fileAccessor->max_user_data_size();
    }

template<typename T>

static memory_size_type tpie::uncompressed_stream< T >::memory_usage ( float  blockFactor = 1.0, bool  includeDefaultFileAccessor = true  ) throw ( )

inlinestatic

Calculate the amount of memory used by a single uncompressed_stream.

Parameters

blockFactor	The block factor you pass to open.
includeDefaultFileAccessor	Unless you are supplying your own file accessor to open, leave this to be true.

Returns

The amount of memory maximally used by the count file_streams.

Definition at line 156 of file uncompressed_stream.h.

References tpie::file_base_crtp< child_t >::block_memory_usage(), tpie::file_accessor::stream_accessor_base< file_accessor_t >::memory_usage(), and tpie::uncompressed_stream< T >::uncompressed_stream().

Referenced by tpie::ami::stream_old< T >::main_memory_usage(), and tpie::ami::stream_old< T >::memory_usage().

                                                      {
        // TODO
        memory_size_type x = sizeof(uncompressed_stream);
        x += block_memory_usage(blockFactor); // allocated in constructor
        if (includeDefaultFileAccessor)
            x += default_file_accessor::memory_usage();
        return x;
    }

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

inlineinherited

Calculate the current offset in the stream.

Returns

The current offset in the stream

Definition at line 90 of file stream_crtp.h.

Referenced by tpie::uncompressed_stream< T >::peek(), and tpie::file_stream_base::truncate().

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

template<typename child_t>

void tpie::file_base_crtp< child_t >::open ( const std::string &  path, access_type  accessType = access_read_write, memory_size_type  userDataSize = 0, cache_hint  cacheHint = access_sequential  ) throw ( stream_exception )

inlineinherited

Open a file.

Parameters

path	The path of the file to open.
accessType	The mode of operation.
userDataSize	The size of the user data we want to store in the file.

Definition at line 207 of file file_base_crtp.h.

                                                                                      {
        self().close();
        self().open_inner(path, accessType, userDataSize, cacheHint);
    }

template<typename child_t>

void tpie::file_base_crtp< child_t >::open ( memory_size_type  userDataSize = 0, cache_hint  cacheHint = access_sequential  ) throw ( stream_exception )

inlineinherited

Open an anonymous temporary file.

The temporary file is deleted when this file is closed.

Definition at line 219 of file file_base_crtp.h.

                                                                                      {
        self().close();
        m_ownedTempFile.reset(tpie_new<temp_file>());
        m_tempFile=m_ownedTempFile.get();
        self().open_inner(m_tempFile->path(), access_read_write, userDataSize, cacheHint);
    }

template<typename child_t>

void tpie::file_base_crtp< child_t >::open ( temp_file &  file, access_type  accessType = access_read_write, memory_size_type  userDataSize = 0, cache_hint  cacheHint = access_sequential  ) throw ( stream_exception )

inlineinherited

Open a temporary file.

The temporary file is not deleted when this file is closed, so several tpie::file objects may use the same temporary file consecutively.

Definition at line 232 of file file_base_crtp.h.

                                                                                      {
        self().close();
        m_tempFile=&file;
        self().open_inner(m_tempFile->path(), accessType, userDataSize, cacheHint);
    }

template<typename child_t>

const std::string& tpie::file_base_crtp< child_t >::path ( ) const throw ( )

inlineinherited

The path of the file opened or the empty string.

Returns

The path of the currently opened file.

Definition at line 194 of file file_base_crtp.h.

Referenced by tpie::pipelining::serialization_bits::reverser_input_t< T >::begin(), and tpie::pipelining::serialization_bits::buffer_input_t< T >::begin().

                                                  {
        assert(m_open);
        return m_fileAccessor->path();
    }

template<typename T>

const item_type& tpie::uncompressed_stream< T >::peek ( )

inline

Get next item from stream without advancing the position.

Definition at line 123 of file uncompressed_stream.h.

References tpie::stream_crtp< file_stream_base >::m_index, tpie::stream_crtp< file_stream_base >::offset(), tpie::stream_crtp< file_stream_base >::size(), and tpie::stream_crtp< file_stream_base >::update_block().

Referenced by tpie::uncompressed_stream< T >::read(), and tpie::uncompressed_stream< T >::read_back().

                             {
        assert(m_open);
        if (m_index >= m_block.size) {
            update_block();
            if (offset() >= size()) {
                throw end_of_stream_exception();
            }
        }
        return reinterpret_cast<item_type*>(m_block.data)[m_index];
    }

template<typename T>

const item_type& tpie::uncompressed_stream< T >::read ( ) throw ( stream_exception )

inline

Read an item from the stream.

Read current item from the stream, and increment the offset by one item.

This will throw an end_of_stream_exception if there are no more items left in the stream.

To ensure that no exception is thrown, check that can_read() returns true.

Returns

The item read from the stream.

See also

file<T>::stream::read()

Definition at line 91 of file uncompressed_stream.h.

References tpie::stream_crtp< file_stream_base >::m_index, and tpie::uncompressed_stream< T >::peek().

                                                            {
        assert(m_open);
        const item_type & x = peek();
        ++m_index;
        return x;
    }

template<typename T>

template<typename IT >

void tpie::uncompressed_stream< T >::read ( const IT &  start, const IT &  end  ) throw ( stream_exception )

inline

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.

See also

file<T>::stream::read(const IT & start, const IT & end)

Definition at line 104 of file uncompressed_stream.h.

References tpie::stream_crtp< file_stream_base >::read_array().

                                                                               {
        assert(m_open);
        read_array(*this, start, end);
    }

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

inlinestaticprotectedinherited

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 165 of file stream_crtp.h.

Referenced by tpie::uncompressed_stream< T >::read().

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

template<typename T>

const item_type& tpie::uncompressed_stream< T >::read_back ( ) throw ( stream_exception )

inline

Read an item from the stream.

Decrement the offset by one, and read current item from the stream.

This will throw an end_of_stream_exception if there are no more items left in the stream.

To ensure that no exception is thrown, check that can_read_back() returns true.

Returns

The item read from the stream.

See also

file<T>::stream::read_back()

Definition at line 114 of file uncompressed_stream.h.

References tpie::uncompressed_stream< T >::peek(), and tpie::uncompressed_stream< T >::skip_back().

                                                                 {
        assert(m_open);
        skip_back();
        return peek();
    }

template<typename child_t>

template<typename TT >

void tpie::file_base_crtp< child_t >::read_user_data ( TT &  data ) throw ( stream_exception )

inlineinherited

Read the user data associated with the file.

Parameters

data	Where to store the user data.

Template Parameters

TT	The type of user data. sizeof(TT) must be less than or equal to the maximum user data size of the stream. TT must be trivially copyable.

Definition at line 125 of file file_base_crtp.h.

                                                           {
        assert(m_open);
        if (sizeof(TT) != user_data_size()) throw io_exception("Wrong user data size");
        m_fileAccessor->read_user_data(reinterpret_cast<void*>(&data), sizeof(TT));
    }

template<typename child_t>

memory_size_type tpie::file_base_crtp< child_t >::read_user_data ( void *  data, memory_size_type  count  )

inlineinherited

Read variable length user data associated with the file.

Parameters

data	The buffer in which to write data.
count	The size of the buffer.

Returns

Number of bytes of user data actually read.

Definition at line 138 of file file_base_crtp.h.

                                                                         {
        assert(m_open);
        return m_fileAccessor->read_user_data(data, count);
    }

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

inlineinherited

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 50 of file stream_crtp.h.

Referenced by tpie::uncompressed_stream< T >::skip(), tpie::uncompressed_stream< T >::skip_back(), and tpie::file_stream_base::truncate().

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

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

inlineinherited

Get the size of the file measured in items.

Returns

The number of items in the file.

Definition at line 132 of file stream_crtp.h.

Referenced by tpie::uncompressed_stream< T >::peek(), and tpie::file_stream_base::truncate().

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

template<typename T>

void tpie::uncompressed_stream< T >::skip ( )

inline

Advance the stream position to the next item.

Definition at line 137 of file uncompressed_stream.h.

References tpie::stream_crtp< file_stream_base >::seek().

                {
        seek(1, current);
    }

template<typename T>

void tpie::uncompressed_stream< T >::skip_back ( )

inline

Advance the stream position to the previous item.

Definition at line 144 of file uncompressed_stream.h.

References tpie::stream_crtp< file_stream_base >::seek().

Referenced by tpie::uncompressed_stream< T >::read_back().

                     {
        seek(-1, current);
    }

void tpie::file_stream_base::truncate ( stream_size_type  size )

inlineinherited

Truncate file to given size.

May only be used when no streams are opened to this file.

See also

file_base::truncate()

Note that when using a file_stream the stream will automatically be rewound if it is beyond the new end of the file.

Definition at line 66 of file file_stream_base.h.

References tpie::file_accessor::stream_accessor_base< file_accessor_t >::byte_size(), tpie::file_stream_base::flush_block(), tpie::stream_crtp< file_stream_base >::m_index, tpie::stream_crtp< file_stream_base >::m_nextBlock, tpie::stream_crtp< file_stream_base >::m_nextIndex, tpie::stream_crtp< file_stream_base >::offset(), tpie::stream_crtp< file_stream_base >::seek(), and tpie::stream_crtp< file_stream_base >::size().

                                                {
        stream_size_type o=offset();
        flush_block();
        m_block.number = std::numeric_limits<stream_size_type>::max();
        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();
        m_size = size;
        m_fileAccessor->truncate(size);
        if (m_tempFile)
            m_tempFile->update_recorded_size(m_fileAccessor->byte_size());
        seek(std::min(o, size));
    }

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

protectedinherited

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.

Referenced by tpie::uncompressed_stream< T >::peek(), and tpie::uncompressed_stream< T >::write().

template<typename child_t>

memory_size_type tpie::file_base_crtp< child_t >::user_data_size ( ) const

inlineinherited

Get current user data size.

Definition at line 175 of file file_base_crtp.h.

Referenced by tpie::file_base_crtp< file_stream_base >::read_user_data().

                                            {
        assert(m_open);
        return m_fileAccessor->user_data_size();
    }

template<typename T>

void tpie::uncompressed_stream< T >::write ( const item_type &  item ) throw ( stream_exception )

inline

Write an item to the stream.

Parameters

item	The item to write to the stream.

See also

file<T>::stream::write(const item_type & item)

Definition at line 64 of file uncompressed_stream.h.

References tpie::file_base_crtp< child_t >::is_writable(), tpie::stream_crtp< file_stream_base >::m_index, and tpie::stream_crtp< file_stream_base >::update_block().

                                                                      {
        assert(m_open);
#ifndef NDEBUG
        if (!is_writable())
            throw io_exception("Cannot write to read only stream");
#endif
        if (m_index >= m_blockItems) update_block();
        reinterpret_cast<item_type*>(m_block.data)[m_index++] = item;
        write_update();
    }

template<typename T>

template<typename IT >

void tpie::uncompressed_stream< T >::write ( const IT &  start, const IT &  end  ) throw ( stream_exception )

inline

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.

See also

file<T>::stream::write(const IT & start, const IT & end)

Definition at line 81 of file uncompressed_stream.h.

References tpie::stream_crtp< file_stream_base >::write_array().

                                                                                {
        assert(m_open);
        write_array(*this, start, end);
    }

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

inlinestaticprotectedinherited

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 211 of file stream_crtp.h.

Referenced by tpie::uncompressed_stream< T >::write().

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

template<typename child_t>

template<typename TT >

void tpie::file_base_crtp< child_t >::write_user_data ( const TT &  data ) throw ( stream_exception )

inlineinherited

Write user data to the stream.

Parameters

data	The user data to store in the stream.

Template Parameters

TT	The type of user data. sizeof(TT) must be less than or equal to the maximum user data size of the stream. TT must be trivially copyable.

Definition at line 152 of file file_base_crtp.h.

                                                                  {
        assert(m_open);
        if (sizeof(TT) > max_user_data_size()) throw io_exception("Wrong user data size");
        m_fileAccessor->write_user_data(reinterpret_cast<const void*>(&data), sizeof(TT));
    }

template<typename child_t>

void tpie::file_base_crtp< child_t >::write_user_data ( const void *  data, memory_size_type  count  )

inlineinherited

Write variable length user data associated with the file.

Throws a stream_exception if the size of the user data exceeds the maximum user data size of the stream.

Parameters

data	The buffer from which to read data.
count	The size of the user data.

Definition at line 167 of file file_base_crtp.h.

                                                                    {
        assert(m_open);
        m_fileAccessor->write_user_data(data, count);
    }

Member Data Documentation

stream_size_type tpie::stream_crtp< file_stream_base >::m_blockStartIndex

protectedinherited

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 255 of file stream_crtp.h.

memory_size_type tpie::stream_crtp< file_stream_base >::m_index

protectedinherited

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

Definition at line 244 of file stream_crtp.h.

Referenced by tpie::uncompressed_stream< T >::peek(), tpie::uncompressed_stream< T >::read(), tpie::file_stream_base::truncate(), and tpie::uncompressed_stream< T >::write().

stream_size_type tpie::stream_crtp< file_stream_base >::m_nextBlock

protectedinherited

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 248 of file stream_crtp.h.

Referenced by tpie::file_stream_base::truncate().

memory_size_type tpie::stream_crtp< file_stream_base >::m_nextIndex

protectedinherited

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

Otherwise, maxint as with m_nextBlock.

Definition at line 251 of file stream_crtp.h.

Referenced by tpie::file_stream_base::truncate().

---

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

• uncompressed_stream.h