Block.h File Reference

#include <casacore/casa/aips.h>
#include <casacore/casa/Utilities/Assert.h>
#include <casacore/casa/Utilities/Copy.h>
#include <casacore/casa/Utilities/DataType.h>
#include <casacore/casa/Containers/Allocator.h>
#include <cstddef>
#include <algorithm>
#include <type_traits>

Go to the source code of this file.

Classes
class	casacore::BlockTrace
class	casacore::Block_internal_IsFundamental< T >
class	casacore::Block_internal_IsPointer< T >
class	casacore::Block< T >
	More...

Namespaces
namespace	casacore
	this file contains all the compiler specific defines

Typedefs
typedef T	casacore::value_type
	Define the STL-style iterators.
typedef T *	casacore::iterator
typedef const T *	casacore::const_iterator
typedef value_type *	casacore::pointer
typedef const value_type *	casacore::const_pointer
typedef value_type &	casacore::reference
typedef const value_type &	casacore::const_reference
typedef size_t	casacore::size_type
typedef ptrdiff_t	casacore::difference_type

Functions
void	casacore::replaceStorage (size_t n, T *&storagePointer, Bool takeOverStorage=True)
	Replace the internal storage with a C-array (i.e.
template<typename Allocator>
void	casacore::replaceStorage (size_t n, T *&storagePointer, Bool takeOverStorage, AllocSpec< Allocator > const &)
T &	casacore::operator[] (size_t index)
	Index into the block (0-based).
Block< T > &	casacore::operator= (const T &val)
	Set all values in the block to "val".
void	casacore::set (const T &val)
T *	casacore::storage ()
	If you really, really, need a "raw" pointer to the beginning of the storage area this will give it to you.
size_t	casacore::nelements () const
	The number of elements contained in this Block<T>.
size_t	casacore::size () const
size_t	casacore::capacity () const
	The capacity in this Block<T>.
Bool	casacore::empty () const
	Is the block empty (i.e.
iterator	casacore::begin ()
	Get the begin and end iterator object for this block.
iterator	casacore::end ()
void	casacore::traceAlloc (const void *addr, size_t sz) const
void	casacore::traceFree (const void *addr, size_t sz) const
static constexpr bool	casacore::init_anyway ()
void	casacore::init (ArrayInitPolicy initPolicy)
void	casacore::deinit ()
void	casacore::dealloc ()
template<typename Allocator>
static Allocator_private::BulkAllocator< typename Allocator::value_type > *	casacore::get_allocator ()
template<typename Allocator>
Bool	casacore::isCompatibleAllocator ()
size_t	casacore::get_size () const
	The number of used elements in the vector.
void	casacore::set_size (size_t new_value)
	Set the number of used elements in the vector.
size_t	casacore::get_capacity () const
	The capacity of the vector.
void	casacore::set_capacity (size_t new_value)
	Set the capacity of the vector.

Variables
Allocator_private::BulkAllocator< T > *	casacore::allocator_p
	The allocator.
size_t	casacore::capacity_p
	The capacity of the vector.
size_t	casacore::used_p
	The number of used elements in the vector.
T *	casacore::array
	The actual storage.
Bool	casacore::destroyPointer
	Can we delete the storage upon destruction?