Public Types

typedef TypedChunk< T > Base_t
typedef Base_t::base_vector_type base_vector_type
typedef Base_t::TypedChunkBase_t TypedBase_t
typedef std::vector< T > vector_type

Public Member Functions

override base_vector_type & base_vector ()
Implement virtual base class function to yield vector of base elements. Internally uses ugly reinterpret_cast<> of STL vectors.
override const base_vector_type & base_vector () const
Implement virtual base class function to yield constant vector of base elements. Internally uses ugly reinterpret_cast<> of STL vectors.
Chunk (size_t N, bool ReserveOnly=false)
Constructor allocates a chunk of data.
Chunk (const std::vector< T > &SourceValues)
Copy values.
Chunk (const std::string &buffer)
Construct a chunk of data from a character set.
override const void * data_ptr () const
override int element_size () const
override size_t elements () const
override const type_info & getType () const
override RefPtr< TypedBase_t > newChunk (size_t N, bool ReserveOnly=false) const
T * operator() ()
Use function call operator to get the actual data pointer Note that this function returns 0 if the data type is not addressible via a pointer, for instance a boolean.
std::vector< T > & std_vector ()
const std::vector< T > & std_vector () const
~Chunk ()
Destructor deletes the data pointer.

Detailed Description

A class which handles a chunk of memory.

It keeps initially allocated memory alive as long as the Chunk object lives, employing the STL vector<> class.

Basically, the Chunk class is a MemCore API to std::vector's with reference pointers, and an induced hierarchy. Induced hierarchy means that if an class B is derived from class A, then also a TypedChunk< B > will be derived from TypedChunk< A >. A TypedChunk<> is the base class of Chunk<> and provides all operator access to the data, which is actually stored in a Chunk<>.

For the hierarchy induction to work, a type trait BaseClass<> must exist for the given type. This is as simple as in this following code segment:

struct  A
{
        int i;
};

struct  B : A
{
};

template <>
struct  BaseClass<B>
{
        typedef A result;
};

In this case, the class hierarchy will be:

Chunk<B> : TypedChunk<B> : TypedChunk<A> : TypedChunkBase<A> : ChunkBase

A any element of this hierarchy can be converted into each other via assignment to a RefPtr<> of another element. For each typed chunk, a std::vector<> can be retrieved. Here, the Chunk can be accessed as an std::vector<B> as well as an std::vector<A> .

Constructor & Destructor Documentation

MemCore::Chunk::Chunk	(	size_t	N,
		bool	ReserveOnly = `false`
	)		`[inline]`

Constructor allocates a chunk of data.

Parameters:

N	Allocate that many objects.
ReserveOnly	Reserve that many objects to be appended later.

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

memcore/Chunk.hpp