mirror of
https://github.com/nasa/trick.git
synced 2024-12-22 06:27:49 +00:00
4c3015851f
Taking in the latest er7_utils directory and adding it into Trick in the same location it was as an external repository. Made one change to the files_to_ICG.hh file in the repository to remove the CheckpointHelper header files. Those go in the Trick files_to_ICG.hh file. refs #180
799 lines
22 KiB
C++
799 lines
22 KiB
C++
/**
|
|
* @if Er7UtilsUseGroups
|
|
* @addtogroup Er7Utils
|
|
* @{
|
|
* @addtogroup Interface
|
|
* @{
|
|
* @endif
|
|
*/
|
|
|
|
/**
|
|
* @file
|
|
* Defines memory management macros and template functions.
|
|
*
|
|
* This file comprises multiple parts:
|
|
* - Declaration of a name demangler function, if available.
|
|
* - Low level, Trick-specific memory management template functions.
|
|
* - Implementation-specific definitions of set of memory management macros.
|
|
* While these macros are defined in implementation-specific manner,
|
|
* the arguments and products are implementation independent.
|
|
* - High-level memory management template functions that are implemented
|
|
* in terms of those four macros. These templates obviate the need
|
|
* for using those macros outside of this file.
|
|
* The ER7 utilities code should use the high level interfaces rather
|
|
* than the memory management macros.
|
|
*/
|
|
|
|
/*
|
|
Purpose: ()
|
|
*/
|
|
|
|
|
|
#ifndef ER7_UTILS_ALLOC_HH
|
|
#define ER7_UTILS_ALLOC_HH
|
|
|
|
// SWIG gets utterly confused by this.
|
|
#ifndef SWIG
|
|
|
|
// Interface includes
|
|
#include "config.hh"
|
|
|
|
// System includes
|
|
#include <cstddef>
|
|
#include <cstring>
|
|
#include <string>
|
|
#include <new>
|
|
|
|
#ifdef ER7_UTILS_HAVE_ABI
|
|
#include <typeinfo>
|
|
#endif
|
|
|
|
|
|
// Declare er7_utils::alloc.
|
|
namespace er7_utils {
|
|
|
|
/**
|
|
* Contains free functions that pertain to initialization (setting to NULL),
|
|
* allocating memory, and releasing allocated memory.
|
|
*/
|
|
namespace alloc {
|
|
}
|
|
}
|
|
|
|
|
|
/******************************************************************************/
|
|
|
|
// The macros below need a demangle function, if available.
|
|
|
|
|
|
#ifdef ER7_UTILS_HAVE_ABI
|
|
namespace er7_utils {
|
|
namespace alloc {
|
|
|
|
/**
|
|
* Demangle a type ID.
|
|
* @param info The type ID whose name is to be demangled.
|
|
* @return Demangled type name.
|
|
*/
|
|
const std::string demangle (const std::type_info & info);
|
|
}
|
|
}
|
|
#endif
|
|
|
|
|
|
/******************************************************************************/
|
|
|
|
// Part one, allocation/deallocation macros.
|
|
|
|
/*
|
|
* Trick-based implementations of the four macros.
|
|
*/
|
|
#ifdef TRICK_VER
|
|
|
|
#include <new>
|
|
#include <string>
|
|
#include "sim_services/MemoryManager/include/memorymanager_c_intf.h"
|
|
#include "type_traits.hh"
|
|
|
|
|
|
namespace er7_utils {
|
|
|
|
/**
|
|
* Contains helper functions for the Trick-specific implementations
|
|
* of the ER7 utilities allocation macros.
|
|
*/
|
|
namespace trick_interface {
|
|
|
|
#ifdef ER7_UTILS_HAVE_ABI
|
|
/**
|
|
* Get the name of a type as a string.
|
|
* @tparam T Type whose name is to be retrieved.
|
|
* @return Demangled type name.
|
|
*/
|
|
template<typename T>
|
|
inline const std::string type_name (std::string) {
|
|
return alloc::demangle (typeid(T));
|
|
}
|
|
#else
|
|
/**
|
|
* Try to get the name of a type as a string.
|
|
* @tparam T Type whose name is to be retrieved.
|
|
* @return Type name.
|
|
*/
|
|
template<typename T>
|
|
inline const std::string type_name (std::string name_of_type) {
|
|
if (name_of_type.find("::") == 0) {
|
|
name_of_type.erase (0, 2);
|
|
}
|
|
else if ((name_of_type.find("Trick::") != 0) &&
|
|
(name_of_type.find("er7_utils::") != 0)) {
|
|
name_of_type.insert (0, "er7_utils::");
|
|
}
|
|
return name_of_type;
|
|
}
|
|
#endif
|
|
|
|
/**
|
|
* Allocate an array of objects of the specified type.
|
|
* The returned array contains default-constructed objects.
|
|
* @tparam T Type of objects to be allocated.
|
|
* @param name_of_type Demangled name of the type.
|
|
* @param count Number of elements to be allocated.
|
|
* @return Array of allocated objects.
|
|
*/
|
|
template <typename T>
|
|
inline T * trick_alloc (
|
|
std::string name_of_type,
|
|
unsigned int count)
|
|
{
|
|
name_of_type = type_name<T> (name_of_type);
|
|
T * ptr = reinterpret_cast<T*> (
|
|
TMM_declare_var_1d (name_of_type.c_str(), count));
|
|
if (!ptr) {
|
|
throw std::bad_alloc();
|
|
}
|
|
return ptr;
|
|
}
|
|
|
|
/**
|
|
* Allocate an object of the specified type.
|
|
* The returned object is not constructed.
|
|
* @tparam T Type of the object to be allocated.
|
|
* @param name_of_type Demangled name of the type.
|
|
* @return Array of allocated objects.
|
|
*/
|
|
template <typename T>
|
|
inline T * alloc_object (std::string name_of_type) {
|
|
T * ptr = trick_alloc<T> (name_of_type, 1);
|
|
ptr->~T();
|
|
return ptr;
|
|
}
|
|
|
|
/**
|
|
* Destruct and deallocate a previously allocated object.
|
|
* @tparam T Type of the object to be deallocated.
|
|
* @param obj Object to be destructed, as a reference to a pointer.
|
|
* @return Array of allocated objects.
|
|
*/
|
|
template <typename T>
|
|
inline void delete_object (T*& obj) {
|
|
if (obj) {
|
|
TMM_delete_var_a (type_traits::get_allocated_pointer (obj));
|
|
obj = 0;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
#endif
|
|
|
|
|
|
/******************************************************************************/
|
|
|
|
// Part two, allocation/deallocation macros.
|
|
|
|
/*
|
|
* Trick-based implementations of the four allocation/deallocation macros.
|
|
* These use the er7_utils::trick_interface template functions defined above.
|
|
*/
|
|
#ifdef TRICK_VER
|
|
|
|
/**
|
|
* Allocate an array of some primitive type.
|
|
* @param size Size of the array to be allocated.
|
|
* @param type Type of the array.
|
|
*/
|
|
#define ER7_UTILS_ALLOC_PRIM_ARRAY(size,type) \
|
|
er7_utils::trick_interface::trick_alloc<type> (#type, size)
|
|
|
|
/**
|
|
* Allocate an object of some class type.
|
|
* @param type Type of the object.
|
|
* @param cotr Constructor arguments, in parentheses.
|
|
*/
|
|
#define ER7_UTILS_ALLOC_CLASS_OBJECT(type,cotr) \
|
|
new (er7_utils::trick_interface::alloc_object<type> (#type)) type cotr
|
|
|
|
/**
|
|
* Delete a previously allocated array.
|
|
* @param arr Array to be deleted.
|
|
*/
|
|
#define ER7_UTILS_DELETE_ARRAY(arr) \
|
|
er7_utils::trick_interface::delete_object (arr)
|
|
|
|
/**
|
|
* Delete a previously allocated instance of a class.
|
|
* @param obj Object to be deleted.
|
|
*/
|
|
#define ER7_UTILS_DELETE_OBJECT(obj) \
|
|
er7_utils::trick_interface::delete_object (obj)
|
|
|
|
|
|
/*
|
|
* JEOD-based implementations of the four macros.
|
|
* Note that the JEOD implementations come into play only in the case
|
|
* of a non-Trick implementation.
|
|
*/
|
|
#elif (defined JEOD)
|
|
|
|
#include "utils/memory/include/jeod_alloc.hh"
|
|
|
|
#define ER7_UTILS_ALLOC_PRIM_ARRAY(size,type) \
|
|
JEOD_ALLOC_PRIM_ARRAY (size, type)
|
|
|
|
#define ER7_UTILS_ALLOC_CLASS_OBJECT(type,cotr) \
|
|
JEOD_ALLOC_PRIM_ARRAY (type, cotr)
|
|
|
|
#define ER7_UTILS_DELETE_ARRAY(arr) \
|
|
JEOD_DELETE_ARRAY(arr)
|
|
|
|
#define ER7_UTILS_DELETE_OBJECT(obj) \
|
|
JEOD_DELETE_OBJECT(obj)
|
|
|
|
|
|
/*
|
|
* Generic implementations of the four macros.
|
|
* Note that the generic implementations come into play only in the case
|
|
* of a non-Trick, non-JEOD implementation.
|
|
*/
|
|
#else
|
|
namespace er7_utils {
|
|
namespace default_interface {
|
|
|
|
template <typename T>
|
|
inline T* allocate_array (std::size_t size) {
|
|
T* arr = new T[size];
|
|
std::memset (arr, 0, size*sizeof(T));
|
|
return arr;
|
|
}
|
|
|
|
template <typename T>
|
|
inline void delete_array (T*& obj) {
|
|
if (obj) {
|
|
delete[] obj;
|
|
obj = 0;
|
|
}
|
|
}
|
|
|
|
template <typename T>
|
|
inline void delete_object (T*& obj) {
|
|
if (obj) {
|
|
delete obj;
|
|
obj = 0;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
#define ER7_UTILS_ALLOC_PRIM_ARRAY(size,type) \
|
|
er7_utils::default_interface::allocate_array<type> (size)
|
|
|
|
#define ER7_UTILS_ALLOC_CLASS_OBJECT(type,cotr) \
|
|
new type cotr
|
|
|
|
#define ER7_UTILS_DELETE_ARRAY(arr) \
|
|
er7_utils::default_interface::delete_array (arr)
|
|
|
|
#define ER7_UTILS_DELETE_OBJECT(obj) \
|
|
er7_utils::default_interface::delete_object (obj)
|
|
|
|
#endif
|
|
|
|
|
|
/******************************************************************************/
|
|
|
|
// Part three, allocation/deallocation template functions.
|
|
|
|
|
|
namespace er7_utils {
|
|
|
|
/**
|
|
* Contains free functions that pertain to initialization (setting to NULL),
|
|
* allocating memory, and releasing allocated memory.
|
|
*/
|
|
namespace alloc {
|
|
|
|
/**
|
|
* Allocate an object of some type using the default constructor.
|
|
* @tparam T Array type.
|
|
* @return Allocated object.
|
|
*/
|
|
template<typename T>
|
|
inline T * allocate_object ()
|
|
{
|
|
return ER7_UTILS_ALLOC_CLASS_OBJECT (T, ());
|
|
}
|
|
|
|
/**
|
|
* Allocate an object of some type using the copy constructor.
|
|
* @tparam T Array type.
|
|
* @param src Argument.
|
|
* @return Allocated object.
|
|
*/
|
|
template<typename T>
|
|
inline T * replicate_object (const T & src)
|
|
{
|
|
return ER7_UTILS_ALLOC_CLASS_OBJECT (T, (src));
|
|
}
|
|
|
|
/**
|
|
* Allocate an object of some type using a one argument constructor.
|
|
* @tparam T Array type.
|
|
* @tparam A1 Argument type.
|
|
* @param arg1 Argument.
|
|
* @return Allocated object.
|
|
*/
|
|
template<typename T, typename A1>
|
|
inline T * allocate_object (
|
|
A1 arg1)
|
|
{
|
|
return ER7_UTILS_ALLOC_CLASS_OBJECT (T, (arg1));
|
|
}
|
|
|
|
/**
|
|
* Allocate an object of some type using a two argument constructor.
|
|
* @tparam T Array type.
|
|
* @tparam A1 Argument 1 type.
|
|
* @tparam A2 Argument 2 type.
|
|
* @param arg1 Argument 1.
|
|
* @param arg2 Argument 2.
|
|
* @return Allocated object.
|
|
*/
|
|
template<typename T, typename A1, typename A2>
|
|
inline T * allocate_object (
|
|
A1 arg1,
|
|
A2 arg2)
|
|
{
|
|
return ER7_UTILS_ALLOC_CLASS_OBJECT (T, (arg1, arg2));
|
|
}
|
|
|
|
/**
|
|
* Allocate an object of some type using a three argument constructor.
|
|
* @tparam T Array type.
|
|
* @tparam A1 Argument 1 type.
|
|
* @tparam A2 Argument 2 type.
|
|
* @tparam A3 Argument 3 type.
|
|
* @param arg1 Argument 1.
|
|
* @param arg2 Argument 2.
|
|
* @param arg3 Argument 3.
|
|
* @return Allocated object.
|
|
*/
|
|
template<typename T, typename A1, typename A2, typename A3>
|
|
inline T * allocate_object (
|
|
A1 arg1,
|
|
A2 arg2,
|
|
A3 arg3)
|
|
{
|
|
return ER7_UTILS_ALLOC_CLASS_OBJECT (T, (arg1, arg2, arg3));
|
|
}
|
|
|
|
/**
|
|
* Allocate an object of some type using a four argument constructor.
|
|
* @tparam T Array type.
|
|
* @tparam A1 Argument 1 type.
|
|
* @tparam A2 Argument 2 type.
|
|
* @tparam A3 Argument 3 type.
|
|
* @tparam A4 Argument 4 type.
|
|
* @param arg1 Argument 1.
|
|
* @param arg2 Argument 2.
|
|
* @param arg3 Argument 3.
|
|
* @param arg4 Argument 4.
|
|
* @return Allocated object.
|
|
*/
|
|
template<typename T, typename A1, typename A2, typename A3, typename A4>
|
|
inline T * allocate_object (
|
|
A1 arg1,
|
|
A2 arg2,
|
|
A3 arg3,
|
|
A4 arg4)
|
|
{
|
|
return ER7_UTILS_ALLOC_CLASS_OBJECT (T, (arg1, arg2, arg3, arg4));
|
|
}
|
|
|
|
/**
|
|
* Allocate an object of some type using a five argument constructor.
|
|
* @tparam T Array type.
|
|
* @tparam A1 Argument 1 type.
|
|
* @tparam A2 Argument 2 type.
|
|
* @tparam A3 Argument 3 type.
|
|
* @tparam A4 Argument 4 type.
|
|
* @tparam A5 Argument 5 type.
|
|
* @param arg1 Argument 1.
|
|
* @param arg2 Argument 2.
|
|
* @param arg3 Argument 3.
|
|
* @param arg4 Argument 4.
|
|
* @param arg5 Argument 5.
|
|
* @return Allocated object.
|
|
*/
|
|
template<typename T,
|
|
typename A1,
|
|
typename A2,
|
|
typename A3,
|
|
typename A4,
|
|
typename A5>
|
|
inline T * allocate_object (
|
|
A1 arg1,
|
|
A2 arg2,
|
|
A3 arg3,
|
|
A4 arg4,
|
|
A5 arg5)
|
|
{
|
|
return ER7_UTILS_ALLOC_CLASS_OBJECT (
|
|
T, (arg1, arg2, arg3, arg4, arg5));
|
|
}
|
|
|
|
/**
|
|
* Allocate an object of some type using a six argument constructor.
|
|
* @tparam T Array type.
|
|
* @tparam A1 Argument 1 type.
|
|
* @tparam A2 Argument 2 type.
|
|
* @tparam A3 Argument 3 type.
|
|
* @tparam A4 Argument 4 type.
|
|
* @tparam A5 Argument 5 type.
|
|
* @tparam A6 Argument 6 type.
|
|
* @param arg1 Argument 1.
|
|
* @param arg2 Argument 2.
|
|
* @param arg3 Argument 3.
|
|
* @param arg4 Argument 4.
|
|
* @param arg5 Argument 5.
|
|
* @param arg6 Argument 6.
|
|
* @return Allocated object.
|
|
*/
|
|
template<typename T,
|
|
typename A1,
|
|
typename A2,
|
|
typename A3,
|
|
typename A4,
|
|
typename A5,
|
|
typename A6>
|
|
inline T * allocate_object (
|
|
A1 arg1,
|
|
A2 arg2,
|
|
A3 arg3,
|
|
A4 arg4,
|
|
A5 arg5,
|
|
A6 arg6)
|
|
{
|
|
return ER7_UTILS_ALLOC_CLASS_OBJECT (
|
|
T, (arg1, arg2, arg3, arg4, arg5, arg6));
|
|
}
|
|
|
|
|
|
/**
|
|
* Delete (and destruct) an instance of some class.
|
|
* @tparam T Object class.
|
|
* @param obj The object to be deleted.
|
|
*/
|
|
template<typename T>
|
|
inline void delete_object (
|
|
T *& obj)
|
|
{
|
|
ER7_UTILS_DELETE_OBJECT (obj);
|
|
}
|
|
|
|
|
|
/**
|
|
* Allocate an array of some primitive type.
|
|
* Note that because none of the arguments involve the type T,
|
|
* invocations of the function template must always specify T.
|
|
* @tparam T Array type.
|
|
* @param size Number of elements to allocate, assumed to be positive.
|
|
* @return Allocated array.
|
|
*/
|
|
template<typename T>
|
|
inline T * allocate_array (unsigned int size)
|
|
{
|
|
return ER7_UTILS_ALLOC_PRIM_ARRAY (size, T);
|
|
}
|
|
|
|
/**
|
|
* Non-template specialization of allocate_array for double.
|
|
* Note that since this is not a function template, calling
|
|
* allocate_array without a template argument will always resolve
|
|
* to this function.
|
|
* @param size Number of elements to allocate, assumed to be positive.
|
|
* @return Allocated array.
|
|
*/
|
|
inline double * allocate_array (unsigned int size)
|
|
{
|
|
return ER7_UTILS_ALLOC_PRIM_ARRAY (size, double);
|
|
}
|
|
|
|
|
|
/**
|
|
* Replicate an array of some primitive type
|
|
* @tparam T Array type.
|
|
* @param size Number of elements to allocate, assumed to be positive.
|
|
* @param src Array to be replicated.
|
|
* @return Allocated array.
|
|
*/
|
|
template<typename T>
|
|
inline T * replicate_array (unsigned int size, const T* src)
|
|
{
|
|
T* result = ER7_UTILS_ALLOC_PRIM_ARRAY (size, T);
|
|
for (unsigned int ii = 0; ii < size; ++ii) {
|
|
result[ii] = src[ii];
|
|
}
|
|
return result;
|
|
}
|
|
|
|
|
|
/**
|
|
* Deallocate an array of some primitive type
|
|
* @tparam T
|
|
* @param arr Array to be deallocated.
|
|
*/
|
|
template<typename T>
|
|
inline void deallocate_array (T *& arr)
|
|
{
|
|
ER7_UTILS_DELETE_ARRAY (arr);
|
|
}
|
|
|
|
|
|
/**
|
|
* Zero out an array of items
|
|
* @param[in] size Array size
|
|
* @param[out] arr Array to zero
|
|
*/
|
|
template<typename T>
|
|
inline void initialize_array (
|
|
unsigned int size,
|
|
T * arr)
|
|
{
|
|
std::memset (arr, 0, size*sizeof(T));
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
* Initialize (zero-out) a 2D array.
|
|
* @tparam T Array type
|
|
* @tparam M Array outer dimension
|
|
* @param[out] arr Array to be initialized
|
|
*/
|
|
template<typename T, unsigned int M>
|
|
inline void initialize_2D_array (
|
|
T * arr[M])
|
|
{
|
|
initialize_array<T*> (M, arr);
|
|
}
|
|
|
|
/**
|
|
* Specialization of initialize_2D_array for double.
|
|
* @tparam M Array outer dimension
|
|
* @param[out] arr Array to be initialized
|
|
*/
|
|
template<unsigned int M>
|
|
inline void initialize_2D_array (
|
|
double * arr[M])
|
|
{
|
|
initialize_array<double*> (M, arr);
|
|
}
|
|
|
|
|
|
/**
|
|
* Allocate contents of a 2D array, where the array is declared as
|
|
* @code T * array[M] @endcode
|
|
* @tparam T Array type
|
|
* @tparam M Array outer dimension
|
|
* @param[in] size Array inner dimension
|
|
* @param[out] arr Array to be allocated
|
|
*/
|
|
template<typename T, unsigned int M>
|
|
inline void allocate_2D_array (
|
|
unsigned int size,
|
|
T * arr[M])
|
|
{
|
|
arr[0] = allocate_array<T> (size*M);
|
|
for (unsigned int ii = 1; ii < M; ++ii) {
|
|
arr[ii] = arr[ii-1] + size;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Specialization of allocate_2D_array for double.
|
|
* @tparam M Array outer dimension
|
|
* @param[in] size Array inner dimension
|
|
* @param[out] arr Array to be allocated
|
|
*/
|
|
template<unsigned int M>
|
|
inline void allocate_2D_array (
|
|
unsigned int size,
|
|
double * arr[M])
|
|
{
|
|
arr[0] = allocate_array<double> (size*M);
|
|
for (unsigned int ii = 1; ii < M; ++ii) {
|
|
arr[ii] = arr[ii-1] + size;
|
|
}
|
|
}
|
|
|
|
|
|
/**
|
|
* Allocate contents of a 2D array, where the array is declared as
|
|
* @code T ** array @endcode
|
|
* @tparam T Array type
|
|
* @tparam outer Array outer dimension
|
|
* @param inner Array inner dimension
|
|
* @return Allocated 2D array.
|
|
*/
|
|
template<typename T>
|
|
inline T** allocate_2D_array (
|
|
unsigned int outer,
|
|
unsigned int inner)
|
|
{
|
|
T** arr = allocate_array<T*> (outer);
|
|
arr[0] = allocate_array<T> (inner*outer);
|
|
for (unsigned int ii = 1; ii < outer; ++ii) {
|
|
arr[ii] = arr[ii-1] + inner;
|
|
}
|
|
return arr;
|
|
}
|
|
|
|
|
|
/**
|
|
* Replicate contents of a 2D array, where the array is declared as
|
|
* @code T * array[M] @endcode
|
|
* @tparam T Array type
|
|
* @tparam M Array outer dimension
|
|
* @param[in] size Array inner dimension
|
|
* @param[in] src Source 2D array
|
|
* @param[out] tgt Array to be allocated and populated
|
|
*/
|
|
template<typename T, unsigned int M>
|
|
inline void replicate_2D_array (
|
|
unsigned int size,
|
|
T * const src[M],
|
|
T * tgt[M])
|
|
{
|
|
for (unsigned int ii = 0; ii < M; ++ii) {
|
|
if (ii == 0) {
|
|
tgt[ii] = allocate_array<T> (size*M);
|
|
}
|
|
else {
|
|
tgt[ii] = tgt[ii-1] + size;
|
|
}
|
|
for (unsigned int jj = 0; jj < size; ++jj) {
|
|
tgt[ii][jj] = src[ii][jj];
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Specialization of replicate_2D_array for double.
|
|
* @tparam T Array type
|
|
* @tparam M Array outer dimension
|
|
* @param[in] size Array inner dimension
|
|
* @param[in] src Source 2D array
|
|
* @param[out] tgt Array to be allocated and populated
|
|
*/
|
|
template<unsigned int M>
|
|
inline void replicate_2D_array (
|
|
unsigned int size,
|
|
double * const src[M],
|
|
double * tgt[M])
|
|
{
|
|
for (unsigned int ii = 0; ii < M; ++ii) {
|
|
if (ii == 0) {
|
|
tgt[ii] = allocate_array<double> (size*M);
|
|
}
|
|
else {
|
|
tgt[ii] = tgt[ii-1] + size;
|
|
}
|
|
for (unsigned int jj = 0; jj < size; ++jj) {
|
|
tgt[ii][jj] = src[ii][jj];
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
/**
|
|
* Replicate contents of a 2D array, where the array is declared as
|
|
* @code T ** array @endcode
|
|
* @tparam T Array type
|
|
* @param outer Array outer dimension
|
|
* @param inner Array inner dimension
|
|
* @param source Array to be replicated
|
|
* @return Allocated and replicated 2D array.
|
|
*/
|
|
template<typename T>
|
|
inline T** replicate_2D_array (
|
|
unsigned int outer,
|
|
unsigned int inner,
|
|
T** source)
|
|
{
|
|
T** tgt = allocate_array<T*> (outer);
|
|
for (unsigned int ii = 0; ii < outer; ++ii) {
|
|
if (ii == 0) {
|
|
tgt[ii] = allocate_array<T> (inner*outer);
|
|
}
|
|
else {
|
|
tgt[ii] = tgt[ii-1] + inner;
|
|
}
|
|
for (unsigned int jj = 0; jj < inner; ++jj) {
|
|
tgt[ii][jj] = source[ii][jj];
|
|
}
|
|
}
|
|
return tgt;
|
|
}
|
|
|
|
|
|
/**
|
|
* Deallocate a 2D array.
|
|
* @tparam T Array type
|
|
* @tparam M Array outer dimension
|
|
* @param[in,out] arr Array to be deallocated
|
|
*/
|
|
template<typename T, unsigned int M>
|
|
inline void deallocate_2D_array (
|
|
T * arr[M])
|
|
{
|
|
deallocate_array<T> (arr[0]);
|
|
}
|
|
|
|
/**
|
|
* Specialization of deallocate_2D_array for double.
|
|
* @tparam T Array type
|
|
* @tparam M Array outer dimension
|
|
* @param[in,out] arr Array to be deallocated
|
|
*/
|
|
template<unsigned int M>
|
|
inline void deallocate_2D_array (
|
|
double * arr[M])
|
|
{
|
|
deallocate_array<double> (arr[0]);
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
* Deallocate a 2D array.
|
|
* @tparam T Array type
|
|
* @tparam outer Array outer dimension
|
|
* @param[in,out] arr Array to be deallocated
|
|
*/
|
|
template<typename T>
|
|
inline void deallocate_2D_array (
|
|
unsigned int outer ER7_UTILS_UNUSED,
|
|
T **& arr)
|
|
{
|
|
if (arr != NULL) {
|
|
deallocate_array<T> (arr[0]);
|
|
deallocate_array<T*> (arr);
|
|
}
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
|
|
#endif
|
|
|
|
#endif
|
|
|
|
/**
|
|
* @if Er7UtilsUseGroups
|
|
* @}
|
|
* @}
|
|
* @endif
|
|
*/
|