CepsMemory.hpp

Go to the documentation of this file.

/*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
   This file is part of CEPS.
 
   CEPS is free software: you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation, either version 3 of the License, or
   (at your option) any later version.
 
   CEPS is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
 
   You should have received a copy of the GNU General Public License
   along with CEPS (see file LICENSE at root of project).
   If not, see <https://www.gnu.org/licenses/>.
 
 
   Copyright 2019-2024 Inria, Universite de Bordeaux
 
   Authors, in alphabetical order:
 
     Pierre-Elliott BECUE, Florian CARO, Yves COUDIERE(*), Andjela DAVIDOVIC, 
     Charlie DOUANLA-LONTSI, Marc FUENTES, Mehdi JUHOOR, Michael LEGUEBE(*), 
     Pauline MIGERDITICHAN, Valentin PANNETIER(*), Nejib ZEMZEMI.
     * : currently active authors
 
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/
 
#pragma once
 
#include "common/core/CepsTypes.hpp"
#include "common/core/CepsFlags.hpp"
#include "common/core/CepsIoMacros.hpp"
#include "common/core/CepsException.hpp"
 
namespace ceps
{
 
  template <typename _Type>
  CepsBool
  isNullPtr(_Type* ptr)
  {
    return ptr == nullptr;
  }
 
  template <typename _Type>
  CepsBool
  isNullPtr(std::shared_ptr<_Type> ptr)
  {
    return ptr.get() == nullptr;
  }
 
  template <typename _Type>
  CepsBool
  isValidPtr(_Type* ptr)
  {
    return not isNullPtr(ptr);
  }
 
 
  template <typename _Type>
  CepsBool
  isValidPtr(std::shared_ptr<_Type> ptr)
  {
    return not isNullPtr(ptr);
  }
 
  template <typename _Type, typename U>
  CepsBool
  isSamePtr(_Type* xptr, U* yptr)
  {
    return (xptr==yptr);
  }
 
  template <typename _Type, typename U>
  CepsBool
  isDifferentPtr(_Type* xptr, U* yptr)
  {
    return not isSamePtr(xptr,yptr);
  }
 
  template <typename _Derived, class _Base>
  _Derived
  runtimeCast(_Base x)
  {
    if constexpr (std::is_pointer_v<_Base>)
    {
      _Derived res = dynamic_cast<_Derived>(x);
      CEPS_ABORT_IF(ceps::isNullPtr(res),
        "invalid dynamic cast from " << typeid(_Base).name() << " to " << typeid(_Derived).name()
      );
      return res;
    }
    else
      return static_cast<_Derived>(x);
  }
  
 
  // --------- AUTO DESTROYER -------------------
 
  template <typename _Type>
  void
  destroyObject (_Type &)
  {}
 
  template <typename _Type>
  void
  destroyObject(_Type*& obj)
  {
    if (obj != nullptr)
      delete obj;
    obj = nullptr;
    return;
  }
 
  template <typename _Type>
  void
  destroyObject(const _Type* obj)
  {
    if (obj != nullptr)
      delete obj;
    return;
  }
 
  template <typename _Type>
  void
  destroyTabular(_Type&)
  {
  }
 
  template <typename _Type>
  void
  destroyTabular(_Type*& obj)
  {
    if (obj != nullptr)
      delete[] obj;
    obj = nullptr;
    return;
  }
 
  template <typename _Type, typename... _Args>
  _Type*
  getNew(_Args... args)
  {
    _Type* arr = new(std::nothrow) _Type(args...);
    // Any case that can be tested ?
    // CEPS_ABORT_IF(ceps::isNullPtr(arr),
    //   "Could not allocate memory for new object"
    // );
    return arr;
  }
 
  template <typename _Type>
  _Type*
  newArray(long unsigned int n, _Type fill=_Type())
  {
    _Type* arr = new _Type[n];
    CEPS_ABORT_IF(ceps::isNullPtr(arr),
      "Could not allocate memory for new object"
    );
    for (CepsUInt i=0; i<n; ++i)
      arr[i] = _Type(fill);
    return arr;
  }
 
  template <typename _Type>
  _Type*
  newCopyArray(_Type* src, long unsigned int n)
  {
    _Type* arr = new(std::nothrow) _Type[n];
    CEPS_ABORT_IF(ceps::isNullPtr(arr),
      "Could not allocate memory for new object"
    );
    memcpy(arr,src,sizeof(_Type)*n);
    return arr;
  }
 
}  // namespace ceps