STK::MemAllocator< Type_, Size_ > Struct Template Reference

template base class for all Allocator classes. More...

#include <STK_MemAllocator.h>

Inheritance diagram for STK::MemAllocator< Type_, Size_ >:

Public Types
enum	{ isNumeric_ = hidden::IsArithmetic<Type_>::yes }
typedef hidden::MemHandler< Type_, Size_ >	MemHandler
typedef hidden::MemChooser< isNumeric_, Type_ >	MemChooser
typedef Type_	Type
typedef hidden::RemoveConst< Type >::Type const &	TypeConst
typedef TRange< Size_ >	AllocatorRange

Public Member Functions
	MemAllocator ()
	Default constructor.
	MemAllocator (AllocatorRange const &I)
	constructor with specified Range
	MemAllocator (AllocatorRange const &I, Type const &value)
	constructor with specified Range and initial value
	MemAllocator (MemAllocator const &T, bool ref=false)
	Copy constructor.
template<int OtherSize_>
	MemAllocator (MemAllocator< Type, OtherSize_ > const &T, bool ref=false)
	Copy constructor.
template<int OtherSize_>
	MemAllocator (MemAllocator< Type, OtherSize_ > const &T, AllocatorRange const &I, bool ref=true)
	Copy constructor.
	MemAllocator (Type *const &q, Range const &I, bool ref)
	Wrapper or copy constructor.
	MemAllocator (Type *const &q, int size, bool ref)
	Wrapper or copy constructor: second form.
	~MemAllocator ()
	destructor.
AllocatorRange const &	range () const
int	begin () const
int	end () const
int	size () const
Type *const &	p_data () const
	Get constant pointer on data.
void	setValue (TypeConst value)
	This method allows to set a value to the allocator.
void	setValue (int pos, TypeConst value)
	This method allows to set a value to the position pos.
TypeConst	elt (int pos) const
	Get the const element number pos.
TypeConst	operator[] (int i) const
Type &	elt (int pos)
	Get the element number pos.
Type &	operator[] (int i)
void	swap (int pos1, int pos2)
	swap two elements of the Allocator.
template<int OtherSize>
void	malloc (TRange< OtherSize > const &I)
	main method for memory allocation.
template<int OtherSize>
void	realloc (TRange< OtherSize > const &I)
	function for main ptr memory reallocation.
void	free ()
	function for main ptr memory deallocation.
template<int OtherSize_, int RangeSize_>
void	memcpy (int pos, MemAllocator< Type, OtherSize_ > const &T, TRange< RangeSize_ > const &range)
	function copying a part of allocator T in this.
template<int RangeSize_>
void	memmove (int pos, TRange< RangeSize_ > const &range)
	function moving a part of the allocator.
void	memmove (int pos, int begin, int size)
	function moving a part of the allocator.
void	exchange (MemAllocator &T)
	exchange this with T.
MemAllocator &	assign (MemAllocator const &T)
	copy the Allocator T by value.
template<int OtherSize_>
MemAllocator &	assign (TRange< OtherSize_ > const &I, Type const &value)
	assign a value to allocator.
MemAllocator &	move (MemAllocator const &T)
	move the Allocator T to this.
MemAllocator &	shift (int first)
	shift the first index of the data to first.
void	setPtr (Type *p_data, Range const &range, bool ref)
	Set address and range of allocated data.
template<int OtherSize_>
MemAllocator< Type, Size_ > &	assign (TRange< OtherSize_ > const &I, Type const &value)
bool	isRef () const
void	setRef (bool ref) const
	Modify the container : can become a reference or the owner of the data.
Public Member Functions inherited from STK::TRef<-1 >
bool	isRef () const
bool	ref () const
void	exchange (TRef const &T)
	swap this with the container T.
void	setRef (bool ref) const
	Modify the container : can become a reference or the owner of the data.

Protected Attributes
Type *	p_data_
	Main pointer on the data.

Private Member Functions
void	shiftPtr (int inc)
	move main pointer on data
void	forcedFree ()
	function for main ptr memory deallocation.

Private Attributes
AllocatorRange	range_
	Range of the data.

Additional Inherited Members
Protected Member Functions inherited from STK::TRef<-1 >
	TRef (bool ref)
	Default constructor We have to specify the member ref_.
	~TRef ()
	destructor.

Detailed Description

template<typename Type_, int Size_>
struct STK::MemAllocator< Type_, Size_ >

template base class for all Allocator classes.

The MemAllocator class is the base class of all memory allocators. This class manages the main pointer on the data. It derives from the IContainerRef class as an array stored in memory can always be wrapped in some way or be a wrapper of some data stored in memory.

Template Parameters

Type_	can be any type of data that can be stored in memory.
Size_	size of the data if it is known at compile time

Definition at line 180 of file STK_MemAllocator.h.

Member Typedef Documentation

AllocatorRange

template<typename Type_ , int Size_>

typedef TRange<Size_> STK::MemAllocator< Type_, Size_ >::AllocatorRange

Definition at line 189 of file STK_MemAllocator.h.

MemChooser

template<typename Type_ , int Size_>

typedef hidden::MemChooser<isNumeric_, Type_> STK::MemAllocator< Type_, Size_ >::MemChooser

Definition at line 184 of file STK_MemAllocator.h.

MemHandler

template<typename Type_ , int Size_>

typedef hidden::MemHandler<Type_, Size_> STK::MemAllocator< Type_, Size_ >::MemHandler

Definition at line 183 of file STK_MemAllocator.h.

Type

template<typename Type_ , int Size_>

typedef Type_ STK::MemAllocator< Type_, Size_ >::Type

Definition at line 186 of file STK_MemAllocator.h.

TypeConst

template<typename Type_ , int Size_>

typedef hidden::RemoveConst<Type>::Type const& STK::MemAllocator< Type_, Size_ >::TypeConst

Definition at line 187 of file STK_MemAllocator.h.

Member Enumeration Documentation

anonymous enum

template<typename Type_ , int Size_>

anonymous enum

Enumerator
isNumeric_

Definition at line 182 of file STK_MemAllocator.h.

{ isNumeric_ = hidden::IsArithmetic<Type_>::yes};

Constructor & Destructor Documentation

MemAllocator() [1/8]

template<typename Type , int Size_>

STK::MemAllocator< Type, Size_ >::MemAllocator

(

)

Default constructor.

Definition at line 412 of file STK_MemAllocator.h.

                                      : IContainerRef(false)
                                        , p_data_(0)
                                        , range_()
{ malloc(range_);}

References STK::MemAllocator< Type_, Size_ >::malloc(), and STK::MemAllocator< Type_, Size_ >::range_.

MemAllocator() [2/8]

template<typename Type , int Size_>

STK::MemAllocator< Type, Size_ >::MemAllocator

(

AllocatorRange const &

I

)

constructor with specified Range

Parameters

I	range of the data

Definition at line 420 of file STK_MemAllocator.h.

                                      : IContainerRef(false), p_data_(0), range_(I)
{ malloc(I);}

References STK::MemAllocator< Type_, Size_ >::malloc().

MemAllocator() [3/8]

template<typename Type , int Size_>

STK::MemAllocator< Type, Size_ >::MemAllocator	(	AllocatorRange const &	I,
		Type const &	value
	)

constructor with specified Range and initial value

Parameters

I,value

range and value of the data

Definition at line 428 of file STK_MemAllocator.h.

                                      : IContainerRef(false), p_data_(0), range_(I)
{ malloc(I);
  assign(I, value);
}

References STK::MemAllocator< Type_, Size_ >::assign(), and STK::MemAllocator< Type_, Size_ >::malloc().

MemAllocator() [4/8]

template<typename Type , int Size_>

STK::MemAllocator< Type, Size_ >::MemAllocator	(	MemAllocator< Type_, Size_ > const &	T,
		bool	ref = false
	)

Copy constructor.

Parameters

T	the array to copy or reference
ref	is this a wrapper of T ? (false by default)

Definition at line 441 of file STK_MemAllocator.h.

                                       : IContainerRef(ref)
                                       , p_data_(ref ? T.p_data(): 0)
                                       , range_(T.range())
{
  if (!ref)
  {
    malloc(range());
    memcpy(begin(), T, range());
  }
}

References STK::MemAllocator< Type_, Size_ >::begin(), STK::MemAllocator< Type_, Size_ >::malloc(), STK::MemAllocator< Type_, Size_ >::memcpy(), STK::MemAllocator< Type_, Size_ >::range(), and STK::TRef<-1 >::ref().

MemAllocator() [5/8]

template<typename Type , int Size_>

template<int OtherSize_>

STK::MemAllocator< Type, Size_ >::MemAllocator	(	MemAllocator< Type, OtherSize_ > const &	T,
		bool	ref = false
	)

Copy constructor.

Copy data or create a reference.

Parameters

T	the array to copy or reference
ref	is this a wrapper of T ? (false by default)

Definition at line 461 of file STK_MemAllocator.h.

                                       : IContainerRef(ref)
                                       , p_data_(ref ? T.p_data(): 0)
                                       , range_(T.range())
{
  if (!ref)
  {
    malloc(range());
    memcpy(begin(), T, range());
  }
}

References STK::MemAllocator< Type_, Size_ >::begin(), STK::MemAllocator< Type_, Size_ >::malloc(), STK::MemAllocator< Type_, Size_ >::memcpy(), STK::MemAllocator< Type_, Size_ >::range(), and STK::TRef<-1 >::ref().

MemAllocator() [6/8]

template<typename Type , int Size_>

template<int OtherSize_>

STK::MemAllocator< Type, Size_ >::MemAllocator	(	MemAllocator< Type, OtherSize_ > const &	T,
		AllocatorRange const &	I,
		bool	ref = true
	)

Copy constructor.

Map a range of T.

Parameters

T,I	the allocator and range to reference
ref	is this a wrapper of a part of T ? (true by default)

Definition at line 477 of file STK_MemAllocator.h.

                                      : IContainerRef(true)
                                      , p_data_(ref ? T.p_data() : 0)
                                      , range_(I)
{
  if (!ref)
  {
    malloc(I);
    for(int i=I.begin(); i< I.end(); ++i)
    { p_data_[i] = T.elt(i);}
  }
}

References STK::MemAllocator< Type_, Size_ >::malloc(), STK::MemAllocator< Type_, Size_ >::p_data_, and STK::TRef<-1 >::ref().

MemAllocator() [7/8]

template<typename Type , int Size_>

STK::MemAllocator< Type, Size_ >::MemAllocator	(	Type *const &	q,
		Range const &	I,
		bool	ref
	)

Wrapper or copy constructor.

Parameters

q,I	ptr and range of the data to wrap
ref	is this a wrapper ? If true data will not be freed when this object is released

Definition at line 496 of file STK_MemAllocator.h.

             : IContainerRef(ref), p_data_(q), range_(I)
{ /* derived class have to delete data if ref==false */}

MemAllocator() [8/8]

template<typename Type , int Size_>

STK::MemAllocator< Type, Size_ >::MemAllocator	(	Type *const &	q,
		int	size,
		bool	ref
	)

Wrapper or copy constructor: second form.

This constructor assumes the data as a C-like array. Thus first index is 0.

Parameters

q,size	ptr and size of the data to wrap
ref	is this a wrapper ? If true data will not be freed when this object is released

Definition at line 507 of file STK_MemAllocator.h.

             : IContainerRef(ref), p_data_(q), range_(AllocatorRange(0,size))
{ /* derived class have to copy the data if ref==false */}

~MemAllocator()

template<typename Type , int Size_>

STK::MemAllocator< Type, Size_ >::~MemAllocator

(

)

destructor.

Release memory.

Definition at line 513 of file STK_MemAllocator.h.

{ forcedFree();}

Member Function Documentation

assign() [1/3]

template<typename Type , int Size_>

MemAllocator< Type, Size_ > & STK::MemAllocator< Type, Size_ >::assign

(

MemAllocator< Type_, Size_ > const &

T

)

copy the Allocator T by value.

The memory is free and the Allocator T is physically copied in this.

Parameters

T	the allocator to copy by value

Returns

a copy of T

Definition at line 532 of file STK_MemAllocator.h.

{
  // allocate memory if necessary
  malloc(T.range_);
  memcpy(begin(), T, range());
  return *this;
}

Referenced by STK::MemAllocator< Type_, Size_ >::MemAllocator().

assign() [2/3]

template<typename Type_ , int Size_>

template<int OtherSize_>

MemAllocator & STK::MemAllocator< Type_, Size_ >::assign	(	TRange< OtherSize_ > const &	I,
		Type const &	value
	)

assign a value to allocator.

Parameters

I,value

range and value to assign

Returns

a copy

assign() [3/3]

template<typename Type_ , int Size_>

template<int OtherSize_>

MemAllocator< Type, Size_ > & STK::MemAllocator< Type_, Size_ >::assign	(	TRange< OtherSize_ > const &	I,
		Type const &	value
	)

Definition at line 543 of file STK_MemAllocator.h.

{
  for (int pos= I.begin(); pos < I.end(); ++pos) { p_data_[pos] = value;}
  return *this;
}

begin()

template<typename Type_ , int Size_>

int STK::MemAllocator< Type_, Size_ >::begin ( ) const

inline

Returns

the first index of the data.

Definition at line 239 of file STK_MemAllocator.h.

{ return range_.begin();}

References STK::MemAllocator< Type_, Size_ >::range_.

Referenced by STK::MemAllocator< Type_, Size_ >::elt(), STK::MemAllocator< Type_, Size_ >::MemAllocator(), STK::MemAllocator< Type_, Size_ >::MemAllocator(), STK::MemAllocator< Type_, Size_ >::memmove(), STK::MemAllocator< Type_, Size_ >::memmove(), STK::MemAllocator< Type_, Size_ >::setValue(), STK::MemAllocator< Type_, Size_ >::setValue(), and STK::MemAllocator< Type_, Size_ >::swap().

elt() [1/2]

template<typename Type_ , int Size_>

Type & STK::MemAllocator< Type_, Size_ >::elt ( int  pos )

inline

Get the element number pos.

Parameters

pos	the position of the element we get

Definition at line 290 of file STK_MemAllocator.h.

{ return p_data_[pos];}

References STK::MemAllocator< Type_, Size_ >::p_data_.

elt() [2/2]

template<typename Type_ , int Size_>

TypeConst STK::MemAllocator< Type_, Size_ >::elt ( int  pos ) const

inline

Get the const element number pos.

Parameters

pos	the position of the element we get

Definition at line 273 of file STK_MemAllocator.h.

  {
#ifdef STK_BOUNDS_CHECK
    if (pos < begin())
    { STKOUT_OF_RANGE_1ARG(MemAllocator::elt,pos,MemAllocator::begin() > pos);}
    if (pos >= end())
    { STKOUT_OF_RANGE_1ARG(MemAllocator::elt,pos,MemAllocator::end() <= pos);}
#endif
    return p_data_[pos];
  }

References STK::MemAllocator< Type_, Size_ >::begin(), STK::MemAllocator< Type_, Size_ >::elt(), STK::MemAllocator< Type_, Size_ >::end(), STK::MemAllocator< Type_, Size_ >::p_data_, and STKOUT_OF_RANGE_1ARG.

Referenced by STK::MemAllocator< Type_, Size_ >::elt(), STK::Array2DNumber< Type_ >::elt0Impl(), STK::Array2DNumber< Type_ >::elt0Impl(), STK::IArray2D< Derived >::elt2Impl(), STK::IArray2D< Derived >::merge(), STK::MemAllocator< Type_, Size_ >::operator[](), STK::MemAllocator< Type_, Size_ >::operator[](), STK::IArray2D< Derived >::ptr(), STK::MemAllocator< Type_, Size_ >::setValue(), STK::IArray2D< Derived >::setValueImpl(), STK::IArray2D< Derived >::transferCol(), and STK::IArray2D< Derived >::transferCol().

end()

template<typename Type_ , int Size_>

int STK::MemAllocator< Type_, Size_ >::end ( ) const

inline

Returns

the ending index of the data

Definition at line 241 of file STK_MemAllocator.h.

{ return range_.end();}

References STK::MemAllocator< Type_, Size_ >::range_.

Referenced by STK::MemAllocator< Type_, Size_ >::elt(), STK::MemAllocator< Type_, Size_ >::memmove(), STK::MemAllocator< Type_, Size_ >::memmove(), STK::MemAllocator< Type_, Size_ >::setValue(), STK::MemAllocator< Type_, Size_ >::setValue(), and STK::MemAllocator< Type_, Size_ >::swap().

exchange()

template<typename Type , int Size_>

void STK::MemAllocator< Type, Size_ >::exchange

(

MemAllocator< Type_, Size_ > &

T

)

exchange this with T.

Parameters

T	the container to exchange with T

Definition at line 520 of file STK_MemAllocator.h.

{
  std::swap(p_data_, T.p_data_);
  std::swap(range_, T.range_);
  IContainerRef::exchange(T);
}

References STK::TRef<-1 >::exchange().

forcedFree()

template<typename Type_ , int Size_>

void STK::MemAllocator< Type_, Size_ >::forcedFree ( )

inlineprivate

function for main ptr memory deallocation.

Force memory deallocation, even for fixed size allocators.

Definition at line 403 of file STK_MemAllocator.h.

    {
      if(!isRef())
      { p_data_ = hidden::MemHandler<Type, UnknownSize>::free(p_data_, range_);}
    }

References STK::hidden::MemHandler< Type_, Size_ >::free(), STK::MemAllocator< Type_, Size_ >::isRef(), STK::MemAllocator< Type_, Size_ >::p_data_, and STK::MemAllocator< Type_, Size_ >::range_.

free()

template<typename Type , int Size_>

void STK::MemAllocator< Type, Size_ >::free

(

)

function for main ptr memory deallocation.

Definition at line 626 of file STK_MemAllocator.h.

{
  // nothing to do for reference
  if (isRef()) return;
  p_data_ = MemHandler::free(p_data_, range_);
  // if there is no elements range_ is set to default
  if (!p_data_) { range_ = AllocatorRange();}
}

isRef()

template<typename Type_ , int Size_>

bool STK::TRef<-1 >::isRef ( ) const

inline

Returns

true if *this is reference container, false otherwise

Definition at line 81 of file STK_IContainerRef.h.

{ return ref_;}

Referenced by STK::MemAllocator< Type_, Size_ >::forcedFree(), and STK::IArray2D< Derived >::isRef().

malloc()

template<typename Type , int Size_>

template<int OtherSize>

void STK::MemAllocator< Type, Size_ >::malloc

(

TRange< OtherSize > const &

I

)

main method for memory allocation.

Parameters

I	range of the data allocated

Definition at line 581 of file STK_MemAllocator.h.

{
  // there is no necessity to allocate if data is already allocated, range_
  // is the same and the data is not owned by an other allocator
  if ((range_ == I)&&(p_data_)&&(!isRef())) return;
  // allocate memory
  try
  {
    // free any existing data and allocate it again (do nothing for fixed size allocators)
    p_data_ = MemHandler::free(p_data_, range_);
    p_data_ = MemHandler::malloc(p_data_, I);
    setPtr(p_data_, I, false);
  }
  catch (std::bad_alloc const& error)
  {
    setPtr(0, AllocatorRange(), false);
    STKRUNTIME_ERROR_1ARG(MemAllocator::malloc, I, memory allocation failed);
  }
}

References STK::IRunnerBase::error(), STK::MemAllocator< Type_, Size_ >::malloc(), and STKRUNTIME_ERROR_1ARG.

Referenced by STK::MemAllocator< Type_, Size_ >::malloc(), STK::MemAllocator< Type_, Size_ >::MemAllocator(), STK::MemAllocator< Type_, Size_ >::MemAllocator(), STK::MemAllocator< Type_, Size_ >::MemAllocator(), STK::MemAllocator< Type_, Size_ >::MemAllocator(), STK::MemAllocator< Type_, Size_ >::MemAllocator(), and STK::MemAllocator< Type_, Size_ >::MemAllocator().

memcpy()

template<typename Type , int Size_>

template<int OtherSize_, int RangeSize_>

void STK::MemAllocator< Type, Size_ >::memcpy	(	int	pos,
		MemAllocator< Type, OtherSize_ > const &	T,
		TRange< RangeSize_ > const &	range
	)

function copying a part of allocator T in this.

Parameters

pos	position where will be copied data
T,range	the array of data and the range of the data to copy

Definition at line 637 of file STK_MemAllocator.h.

{
  if (range.size() <= 0) return;
#ifdef STK_BOUNDS_CHECK
  if (pos < begin()) { STKOUT_OF_RANGE_1ARG(MemAllocator::memcpy,pos,begin() > pos);}
  if (pos >= end())  { STKOUT_OF_RANGE_1ARG(MemAllocator::memcpy,pos,end() <= pos);}
  if (!T.range().isContaining(range))
  { STKOUT_OF_RANGE_1ARG(MemAllocator::memcopy,range,range not in T.range());}
#endif
  MemChooser::memcpy(p_data_+pos, T.p_data()+range.begin(), range.size());
}

References STK::MemAllocator< Type_, Size_ >::memcpy(), and STKOUT_OF_RANGE_1ARG.

Referenced by STK::MemAllocator< Type_, Size_ >::MemAllocator(), STK::MemAllocator< Type_, Size_ >::MemAllocator(), and STK::MemAllocator< Type_, Size_ >::memcpy().

memmove() [1/2]

template<typename Type , int Size_>

void STK::MemAllocator< Type, Size_ >::memmove	(	int	pos,
		int	begin,
		int	size
	)

function moving a part of the allocator.

Parameters

pos,begin,size

range in form [begin,begin+size) to move at position pos

Definition at line 650 of file STK_MemAllocator.h.

{
  if ((size <= 0)||(start == pos)) return;
#ifdef STK_BOUNDS_CHECK
  if (pos < begin())
  { STKOUT_OF_RANGE_1ARG(MemAllocator::memmove,pos,MemAllocator::begin() > pos);}
  if (pos >= end())
  { STKOUT_OF_RANGE_1ARG(MemAllocator::memmove,pos,MemAllocator::end() <= pos);}
  if (!range_.isContaining(Range(start,size)))
  { STKOUT_OF_RANGE_2ARG(MemAllocator::memmove,start,size,Range(start,size) not in range_);}
#endif
  MemChooser::memmove( p_data_+pos, p_data_+ start, size);
}

References STK::MemAllocator< Type_, Size_ >::begin(), STK::MemAllocator< Type_, Size_ >::end(), STK::MemAllocator< Type_, Size_ >::memmove(), STKOUT_OF_RANGE_1ARG, and STKOUT_OF_RANGE_2ARG.

memmove() [2/2]

template<typename Type , int Size_>

template<int RangeSize_>

void STK::MemAllocator< Type, Size_ >::memmove	(	int	pos,
		TRange< RangeSize_ > const &	range
	)

function moving a part of the allocator.

Parameters

pos,range

range in form [begin,end) to move at position pos

Definition at line 666 of file STK_MemAllocator.h.

{
  if ((range.size() <= 0)||(range.begin() == pos)) return;
#ifdef STK_BOUNDS_CHECK
  if (pos < begin())
  { STKOUT_OF_RANGE_1ARG(MemAllocator::memmove,pos,MemAllocator::begin() > pos);}
  if (pos >= end())
  { STKOUT_OF_RANGE_1ARG(MemAllocator::memmove,pos,MemAllocator::end() <= pos);}
  if (!range_.isContaining(range))
  { STKOUT_OF_RANGE_1ARG(MemAllocator::memmove,range,range not in range_);}
#endif
  MemChooser::memmove( p_data_+pos, p_data_+range.begin(), range.size());
}

References STK::MemAllocator< Type_, Size_ >::begin(), STK::MemAllocator< Type_, Size_ >::end(), STK::MemAllocator< Type_, Size_ >::memmove(), and STKOUT_OF_RANGE_1ARG.

Referenced by STK::MemAllocator< Type_, Size_ >::memmove(), and STK::MemAllocator< Type_, Size_ >::memmove().

move()

template<typename Type , int Size_>

MemAllocator< Type, Size_ > & STK::MemAllocator< Type, Size_ >::move

(

MemAllocator< Type_, Size_ > const &

T

)

move the Allocator T to this.

The memory of this is freed and T becomes a reference of this. This method allow to move the data of T to this without using physical copy.

Parameters

T	the allocator to move to this

Returns

this object.

Note

the data member ref_ is mutable so that T can be passed as a constant reference.

Definition at line 558 of file STK_MemAllocator.h.

{
  if (this == &T) return *this;
  forcedFree();
  setPtr(T.p_data_, T.range_, T.isRef());
  T.setRef(true); // T become a reference of the data it own
  return *this;
}

operator[]() [1/2]

template<typename Type_ , int Size_>

Type & STK::MemAllocator< Type_, Size_ >::operator[] ( int  i )

inline

Returns

ith element

Parameters

i	index of the element to get

Definition at line 294 of file STK_MemAllocator.h.

{ return elt(i);}

References STK::MemAllocator< Type_, Size_ >::elt().

operator[]() [2/2]

template<typename Type_ , int Size_>

TypeConst STK::MemAllocator< Type_, Size_ >::operator[] ( int  i ) const

inline

Returns

a constant reference on the ith element

Parameters

i	index of the element to get

Definition at line 286 of file STK_MemAllocator.h.

{ return elt(i);}

References STK::MemAllocator< Type_, Size_ >::elt().

p_data()

template<typename Type_ , int Size_>

Type *const & STK::MemAllocator< Type_, Size_ >::p_data ( ) const

inline

Get constant pointer on data.

Definition at line 246 of file STK_MemAllocator.h.

{ return p_data_;}

References STK::MemAllocator< Type_, Size_ >::p_data_.

Referenced by STK::IArray2D< Derived >::merge(), and STK::MemAllocator< Type_, Size_ >::setPtr().

range()

template<typename Type_ , int Size_>

AllocatorRange const & STK::MemAllocator< Type_, Size_ >::range ( ) const

inline

Returns

the range of the data

Definition at line 237 of file STK_MemAllocator.h.

{ return range_;}

References STK::MemAllocator< Type_, Size_ >::range_.

Referenced by STK::MemAllocator< Type_, Size_ >::MemAllocator(), STK::MemAllocator< Type_, Size_ >::MemAllocator(), and STK::MemAllocator< Type_, Size_ >::setPtr().

realloc()

template<typename Type , int Size_>

template<int OtherSize>

void STK::MemAllocator< Type, Size_ >::realloc

(

TRange< OtherSize > const &

I

)

function for main ptr memory reallocation.

If the size requested is greater than the allocated size, the Type stored are saved and copied using the operator=. the Type class have to provide this operator.

If the size requested is lesser than the allocated size, only the first elements fitting in the container are copied.

Parameters

I	range of the data to reserve

Definition at line 603 of file STK_MemAllocator.h.

{
  // there is no necessity to allocate if data is already allocated, range_
  // is the same and the data is not owned by an other allocator
  if ((range_ == I)&&(p_data_)&&(!isRef())) return;
 
  try
  {
    // allocate memory and copy data in the same range
    Type* p  = MemHandler::malloc(p_data_, I);
    // copy data in common range
    Range r = inf(range_, I);
    if (r.size()>0)
    { MemChooser::memcpy(p+r.begin(), p_data_+r.begin(), r.size());      }
//    for (int i = r.begin(); i<r.end(); ++i) { p[i] = p_data_[i];}
    p_data_ = MemHandler::free(p_data_, range_);
    setPtr(p, I, false);
  }
  catch (std::bad_alloc const& error)
  { STKRUNTIME_ERROR_1ARG(MemAllocator::realloc, I, memory allocation failed);}
}

References STK::RangeBase< Derived >::begin(), STK::IRunnerBase::error(), STK::inf(), STK::MemAllocator< Type_, Size_ >::realloc(), STK::TRange< UnknownSize >::size(), and STKRUNTIME_ERROR_1ARG.

Referenced by STK::MemAllocator< Type_, Size_ >::realloc().

setPtr()

template<typename Type_ , int Size_>

void STK::MemAllocator< Type_, Size_ >::setPtr ( Type *  p_data, Range const &  range, bool  ref  )

inline

Set address and range of allocated data.

This method is to be used when the memory have been allocated outside. If allocator wrap allocated memory, it is not freed.

Parameters

p_data	the address to set
range	range of the data
ref	is p_data_ a wrapper ?

Definition at line 382 of file STK_MemAllocator.h.

  { p_data_ = p_data; range_ = range; setRef(ref);}

References STK::MemAllocator< Type_, Size_ >::p_data(), STK::MemAllocator< Type_, Size_ >::p_data_, STK::MemAllocator< Type_, Size_ >::range(), STK::MemAllocator< Type_, Size_ >::range_, STK::TRef<-1 >::ref(), and STK::MemAllocator< Type_, Size_ >::setRef().

setRef()

template<typename Type_ , int Size_>

void STK::TRef<-1 >::setRef ( bool  ref ) const

inline

Modify the container : can become a reference or the owner of the data.

To use with care if we want to avoid memory leak.

Parameters

ref	: false if this own its own data.

Definition at line 92 of file STK_IContainerRef.h.

{ ref_ = ref;}

Referenced by STK::MemAllocator< Type_, Size_ >::setPtr().

setValue() [1/2]

template<typename Type_ , int Size_>

void STK::MemAllocator< Type_, Size_ >::setValue ( int  pos, TypeConst  value  )

inline

This method allows to set a value to the position pos.

Parameters

pos,value

index and value to set

Definition at line 259 of file STK_MemAllocator.h.

  {
#ifdef STK_BOUNDS_CHECK
    if (pos < begin())
    { STKOUT_OF_RANGE_1ARG(MemAllocator::elt,pos,MemAllocator::begin() > pos);}
    if (pos >= end())
    { STKOUT_OF_RANGE_1ARG(MemAllocator::elt,pos,MemAllocator::end() <= pos);}
#endif
    p_data_[pos] = value;
  }

References STK::MemAllocator< Type_, Size_ >::begin(), STK::MemAllocator< Type_, Size_ >::elt(), STK::MemAllocator< Type_, Size_ >::end(), STK::MemAllocator< Type_, Size_ >::p_data_, and STKOUT_OF_RANGE_1ARG.

setValue() [2/2]

template<typename Type_ , int Size_>

void STK::MemAllocator< Type_, Size_ >::setValue ( TypeConst  value )

inline

This method allows to set a value to the allocator.

Parameters

value

value to set

Definition at line 251 of file STK_MemAllocator.h.

  {
    for(int pos=begin(); pos < end(); ++pos)
    { p_data_[pos] = value;}
  }

References STK::MemAllocator< Type_, Size_ >::begin(), STK::MemAllocator< Type_, Size_ >::end(), and STK::MemAllocator< Type_, Size_ >::p_data_.

shift()

template<typename Type , int Size_>

MemAllocator< Type, Size_ > & STK::MemAllocator< Type, Size_ >::shift

(

int

first

)

shift the first index of the data to first.

Parameters

first

the index of the first data to set

Definition at line 567 of file STK_MemAllocator.h.

{
  // check if there is something to do
  if (first == begin()) return *this;
  // check for reference
  if (isRef())
    STKRUNTIME_ERROR_1ARG(MemAllocator::shift,first,cannot operate on reference);
  // translate data
  shiftPtr(first - begin());
  return *this;
}

References STK::MemAllocator< Type_, Size_ >::shift(), and STKRUNTIME_ERROR_1ARG.

Referenced by STK::MemAllocator< Type_, Size_ >::shift().

shiftPtr()

template<typename Type_ , int Size_>

void STK::MemAllocator< Type_, Size_ >::shiftPtr ( int  inc )

inlineprivate

move main pointer on data

Parameters

inc	the increment to apply

Definition at line 395 of file STK_MemAllocator.h.

    {
      if (p_data_) { p_data_ -= inc;}
      range_.inc(inc);
    }

References STK::MemAllocator< Type_, Size_ >::p_data_, and STK::MemAllocator< Type_, Size_ >::range_.

size()

template<typename Type_ , int Size_>

int STK::MemAllocator< Type_, Size_ >::size ( ) const

inline

Returns

the size of the data

Definition at line 243 of file STK_MemAllocator.h.

{ return range_.size();}

References STK::MemAllocator< Type_, Size_ >::range_.

Referenced by STK::IArray2D< Derived >::availableCols().

swap()

template<typename Type_ , int Size_>

void STK::MemAllocator< Type_, Size_ >::swap ( int  pos1, int  pos2  )

inline

swap two elements of the Allocator.

Parameters

pos1,pos2

the positions to swap

Definition at line 298 of file STK_MemAllocator.h.

  {
#ifdef STK_BOUNDS_CHECK
    if (begin() > pos1) { STKOUT_OF_RANGE_2ARG(MemAllocator::swap, pos1, pos2, begin() > pos1);}
    if (begin() > pos2) { STKOUT_OF_RANGE_2ARG(MemAllocator::swap, pos1, pos2, begin() > pos2);}
    if (end() <= pos1)  { STKOUT_OF_RANGE_2ARG(MemAllocator::swap[], pos1, pos2, end() <= pos1);}
    if (end() <= pos2)  { STKOUT_OF_RANGE_2ARG(MemAllocator::swap[], pos1, pos2, end() <= pos2);}
#endif
    std::swap(p_data_[pos1], p_data_[pos2]);
  }

References STK::MemAllocator< Type_, Size_ >::begin(), STK::MemAllocator< Type_, Size_ >::end(), STK::MemAllocator< Type_, Size_ >::p_data_, STKOUT_OF_RANGE_2ARG, and STK::MemAllocator< Type_, Size_ >::swap().

Referenced by STK::MemAllocator< Type_, Size_ >::swap(), and STK::IArray2D< Derived >::swapCols().

Member Data Documentation

p_data_

template<typename Type_ , int Size_>

Type* STK::MemAllocator< Type_, Size_ >::p_data_

protected

Main pointer on the data.

Definition at line 387 of file STK_MemAllocator.h.

Referenced by STK::MemAllocator< Type_, Size_ >::elt(), STK::MemAllocator< Type_, Size_ >::elt(), STK::MemAllocator< Type_, Size_ >::forcedFree(), STK::MemAllocator< Type_, Size_ >::MemAllocator(), STK::MemAllocator< Type_, Size_ >::p_data(), STK::MemAllocator< Type_, Size_ >::setPtr(), STK::MemAllocator< Type_, Size_ >::setValue(), STK::MemAllocator< Type_, Size_ >::setValue(), STK::MemAllocator< Type_, Size_ >::shiftPtr(), and STK::MemAllocator< Type_, Size_ >::swap().

range_

template<typename Type_ , int Size_>

AllocatorRange STK::MemAllocator< Type_, Size_ >::range_

private

Range of the data.

Definition at line 391 of file STK_MemAllocator.h.

Referenced by STK::MemAllocator< Type_, Size_ >::begin(), STK::MemAllocator< Type_, Size_ >::end(), STK::MemAllocator< Type_, Size_ >::forcedFree(), STK::MemAllocator< Type_, Size_ >::MemAllocator(), STK::MemAllocator< Type_, Size_ >::range(), STK::MemAllocator< Type_, Size_ >::setPtr(), STK::MemAllocator< Type_, Size_ >::shiftPtr(), and STK::MemAllocator< Type_, Size_ >::size().

---

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

• STK_MemAllocator.h