BufferHeadC<class DataC> - Refrenced counted data buffer body.

Developer Documentation

Centre for Vision, Speech & Signal Processing

Comments:
The class BufferHeadC is a reference counted access to a container based on continuous storing of elements randomly accessed by indexing.

Parent Classes:

BodyRefCounterVC

BufferAccessC

Methods:

BufferHeadC(): Creates an empty buffer.
BufferHeadC(const SizeT n): Creates the buffer able to contain up to 'n' elements. If 'n'==0, a default empty buffer is created.
BufferHeadC(DataC * bp,BooleanT remove = TRUE): Creates a buffer using pointer 'bp' to a sufficient memory. The memory is deallocated using delete operator during destroying of this object if variable 'remove' is TRUE.
~BufferHeadC(): Destructor.
This is virtual to allow handling of special buffers. Access functions ----------------
const DataC & operator[](const IndexT i) const: Read-only access to the ('i'+1)-th element of the buffer.
DataC & operator[](const IndexT i): Read-write access to the ('i'+1)-th element of the buffer.
DataC * ReferenceElm() const: Returns the pointer to the reference element of the attached buffer. The reference element need not to be the valid element of the buffer.
void * ReferenceVoid() const: Returns the pointer to the reference element of the attached buffer. The reference element need not to be the valid element of the buffer. The function is intended to be used in printing.
const BufferAccessC<DataC> & Access() const: Returns this object.
BufferHeadC(const BufferHeadC<DataC> & ba): A copy cannot be created because the size is not known. It is not shared therefore it cannot point to the copied buffer.
const BufferHeadC<DataC> & operator=(BufferHeadC<DataC> & b): A copy cannot be created because the size is not known. It is not shared therefore it cannot point to the copied buffer.

#include "amma/BRefCntV.hh"

BodyRefCounterVC & Copy() const: Creat a copy of this object.
BooleanT operator==(const BodyRefCounterVC & oth) const: Compair identitys.
BooleanT operator!=(const BodyRefCounterVC & oth) const: Compair identitys.
BooleanT Save(ostream & out) const: Save to ostream.

#include "amma/BfAccess.hh"

const BufferAccessC<DataC> & operator=(DataC * bp): Changes the reference element to the element pointed by 'bp'.
const BufferAccessC<DataC> & operator=(const BufferAccessC<DataC> & bp): Changes the reference element to the element pointed by 'bp'. Access methods --------------
const DataC & operator[](const IndexT i) const: Read-only access to the ('i'+1)-th element of the buffer.
DataC & operator[](const IndexT i): Read-write access to the ('i'+1)-th element of the buffer.
DataC * ReferenceElm(void) const: Returns the pointer to the reference element of the attached buffer. The reference element need not to be the valid element of the buffer.
void * ReferenceVoid(void) const: Returns the pointer to the reference element of the attached buffer. The reference element need not to be the valid element of the buffer. The function is intended to be used in printing.
const BufferAccessC<DataC> & Access(void) const: Returns this object. Logical functions -----------------
BooleanT IsValid() const: Returns TRUE if this buffer access is not a default access object. Object modifications --------------------
const BufferAccessC<DataC> & Swap(BufferAccessC<DataC> & a): Reference elements of both buffer accesses are mutually exchanged. The return value is this object.
BufferAccessC<DataC> & operator++(): Shifts the reference element one position to the right (towards the next element) - post-fix notation.
BufferAccessC<DataC> & operator++(int): Shifts the reference element one position to the right (towards the next element) - pre-fix notation.
BufferAccessC<DataC> & operator--(): Shifts the reference element one position to the left (towards the previous element) - post-fix notation.
BufferAccessC<DataC> & operator--(int): Shifts the reference element one position to the left (towards the previous element) - pre-fix notation.
const BufferAccessC<DataC> & operator+=(const IndexT i): Shifts the reference element 'i' positions to the right (towards next elements).
const BufferAccessC<DataC> & operator-=(const IndexT i): Shifts the reference element 'i' positions to the left (towards previous elements).
BufferAccessC<DataC> operator+(const IndexT i) const: Creates the new access object with the reference element shifted 'i' positions to the right (towards next elements).
BufferAccessC<DataC> operator-(const IndexT i) const: Creates the new access object with the reference element shifted 'i' positions to the left (towards previous elements).
BufferAccessC<DataC> & NCAccess(): Returns this access.

#include "amma/BRefCnt.hh"

void AddReference(): Another reference to the object has been created.
void RemoveReference(): One reference to the object was deleted.
Locking scheme -------------- The object is possible to lock (to make constant). The scheme assumes that the object is created, it can be locked, after that it can only be destroyed. The locked object cannot be unlocked. This locking scheme is very useful during debugging, using assert() function, when it is necassary to check that object is treated as constant and the constancy is not violated by any casting or passing through the copy constructor of shared objects.
void SetConst(void) const: This locks the object.
Often objects you wish to lock are already const.
void SetConst(void): This locks the object.
BooleanT IsConst(void) const: Returns TRUE if the object is locked, ie. it is assumed to be constant.
BooleanT IsNotConst(void) const: Returns TRUE if the object is unlocked.
ie. there is no special information if the object is constant or not. Counter state information -------------------------
BooleanT ToBeDeleted() const: Returns TRUE if there is only one reference to the object and the whole object or its reference counting part can be deleted.
BooleanT ToBeDeletedRemoveIgnoreNoRemove(): Decrement refrence by 1 return true if this leaves no refrences to the object.
BooleanT ToBeDeletedRemove(): Decrement refrence by 1 return true if this leaves no refrences to the object. This also checks the NoRemove flag.
BooleanT BodyMightBeDeleted() const: Returns TRUE if the reference counted part of the object can be deleted, ie. flag NOREMOVE is false .
BooleanT IsCountZero() const: Are there any refrences left ?
BooleanT BRCPtrCanDeleteObject() const: Used by BRRCPtrC to establish if an object has ZERO refrences and can be deleted.
IntT Count() const: Returns the current state of the counter, ie. how many references to this object exist.
const BodyRefCounterC & operator=(const BodyRefCounterC & b): It has not meaning to assign object 'b' to this object because it would destroy a history of the object which is counted. So this is a dummy function.
BooleanT IsValidObject() const: Test if object is valid.
When amma check is disabled this always returns true.
BooleanT UserBitTest(IntT x) const: Test user flag.
void UserBitSet(IntT x,BooleanT setit = TRUE): Test user flag.
void UserBitZero(IntT x): Set bit to zero.
void ReportBRCError(char * Msg): Report error, used in BRCPtrC.
UIntT Hash() const: Hash on address of object.
void SetUndeletable(): Make object undeletable.
Usefull to prevent recursive deleting in graph structures. Only hackers need this function.
void ReportInvalidObject(char * Msg = 0) const: Tell user about validation failure.

#include "amma/RefCBase.hh"

LabelT Label() const: Returns the label of this reference counter.
The member function is useful mainly to recognize objects during debugging. The value of the label is uniquely defined pointer.

Programmer:Radek Marik, Documentation by CxxDoc: Tue Mar 20 10:49:27 2001

BufferHeadC<class DataC>

Refrenced counted data buffer body.

include	"amma/BuffHead.hh"
User Level:	Default
Library:	Mbuff
Example:	exBuffer.cc
Section:	Containers.Arrays.Buffer
In Scope:	std