tpie::file_base_crtp< child_t > Class Template Reference

Base class of classes that access files. More...

#include <tpie/file_base_crtp.h>

Inherited by tpie::file_stream_base.

Public Member Functions
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_items () const
	Get the number of items per block. More...
memory_size_type	block_size () const
	Get the size of a block in bytes. More...
template<typename TT >
void	read_user_data (TT &data)
	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)
	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)
	Open a file. More...
void	open (memory_size_type userDataSize=0, cache_hint cacheHint=access_sequential)
	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)
	Open a temporary file. More...
void	close ()
	Close the 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...

Static Public Member Functions
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	open_inner (const std::string &path, access_type accessType, memory_size_type userDataSize, cache_hint cacheHint)
	file_base_crtp (memory_size_type itemSize, double blockFactor, file_accessor::file_accessor *fileAccessor)
template<typename BT >
void	read_block (BT &b, stream_size_type block)
void	get_block_check (stream_size_type block)

Protected Attributes
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

Detailed Description

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

Base class of classes that access files.

Inheriting classes may wish to override open_inner() and close(), e.g. to initialize and deinitialize block buffers. open_inner() in the inheriting class will not be called twice in a row without an intervening call to close(). The default implementation of open_inner() passes the open on to the file accessor and sets some attributes.

Definition at line 50 of file file_base_crtp.h.

Member Function Documentation

block_items()

template<typename child_t >

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

inline

Get the number of items per block.

Definition at line 106 of file file_base_crtp.h.

                                         {
        return m_blockItems;
    }

block_memory_usage()

template<typename child_t >

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

inlinestatic

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

Definition at line 99 of file file_base_crtp.h.

                                                                          {
        return block_size(blockFactor);
    }

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

block_size() [1/2]

template<typename child_t >

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

inline

Get the size of a block in bytes.

Definition at line 113 of file file_base_crtp.h.

                                        {
        return m_blockSize;
    }

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

block_size() [2/2]

template<typename child_t >

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

inlinestatic

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 79 of file file_base_crtp.h.

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

calculate_block_factor()

template<typename child_t >

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

inlinestatic

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 92 of file file_base_crtp.h.

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

close()

template<typename child_t >

void tpie::file_base_crtp< child_t >::close ( )

inline

Close the file.

Note all streams into the file must be freed before you call close.

Definition at line 247 of file file_base_crtp.h.

                        {
        if (m_open) m_fileAccessor->close();
        m_open = false;
        m_tempFile = NULL;
        m_ownedTempFile.reset();
    }

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

file_size()

template<typename child_t >

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

inline

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 269 of file file_base_crtp.h.

                                                      {
        return m_size;
    }

is_open()

template<typename child_t >

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

inline

Check if file is open.

Definition at line 257 of file file_base_crtp.h.

                                {
        return m_open;
    }

is_readable()

template<typename child_t >

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

inline

Check if we can read from the file.

Returns

True if we can read from the file.

Definition at line 57 of file file_base_crtp.h.

                                     {
        return m_canRead;
    }

is_writable()

template<typename child_t >

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

inline

Check if we can write to the file.

Returns

True if we can write to the file.

Definition at line 66 of file file_base_crtp.h.

                                     {
        return m_canWrite;
    }

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

max_user_data_size()

template<typename child_t >

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

inline

Get maximum user data size.

Definition at line 184 of file file_base_crtp.h.

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

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

open() [1/3]

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  )

inline

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 208 of file file_base_crtp.h.

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

open() [2/3]

template<typename child_t >

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

inline

Open an anonymous temporary file.

The temporary file is deleted when this file is closed.

Definition at line 220 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);
    }

open() [3/3]

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  )

inline

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 233 of file file_base_crtp.h.

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

path()

template<typename child_t >

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

inline

The path of the file opened or the empty string.

Returns

The path of the currently opened file.

Definition at line 195 of file file_base_crtp.h.

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

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

read_user_data() [1/2]

template<typename child_t >

template<typename TT >

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

inline

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

read_user_data() [2/2]

template<typename child_t >

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

inline

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 139 of file file_base_crtp.h.

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

user_data_size()

template<typename child_t >

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

inline

Get current user data size.

Definition at line 176 of file file_base_crtp.h.

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

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

write_user_data() [1/2]

template<typename child_t >

template<typename TT >

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

inline

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

write_user_data() [2/2]

template<typename child_t >

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

inline

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 168 of file file_base_crtp.h.

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

---

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

• file_base_crtp.h