Alloc.hpp

Go to the documentation of this file.

#ifndef SOLIDUTILS_INCLUDE_ALLOC_HPP
#define SOLIDUTILS_INCLUDE_ALLOC_HPP



#include <cstring>
#include <new>
#include <string>


namespace sl
{


class NotEnoughMemoryException :
    public std::bad_alloc
{
  public:
      NotEnoughMemoryException(
          size_t const numChunks,
          size_t const chunkSize) noexcept :
        std::bad_alloc(),
        m_msg(std::string("Failed to allocate ") + \
              std::to_string(numChunks*chunkSize) + \
              std::string(" bytes in ") + std::to_string(numChunks) + \
              std::string(" chunks of size ") + \
              std::to_string(chunkSize) + std::string("."))
      {
        // do nothing
      }

      const char * what() const noexcept override
      {
        return m_msg.c_str();
      }

  private:
    std::string m_msg;
};


class Alloc
{
  public:
    template<typename T>
    static T * uninitialized(
        size_t const num)
    {
      constexpr size_t const chunkSize = sizeof(T);

      size_t const numBytes = chunkSize*num;

      if (numBytes > 0) {
        T * const data = reinterpret_cast<T*>(malloc(numBytes));

        if (data == nullptr) {
          throw NotEnoughMemoryException(num, chunkSize);
        }
        return data;
      } else {
        return nullptr;
      }
    }


    template<typename T>
    static T * initialized(
        size_t const num,
        T const val = static_cast<T>(0))
    {
      T * const data = uninitialized<T>(num);
      for (size_t i = 0; i < num; ++i) {
        data[i] = val;
      }

      return data;
    }

    template<typename T>
    static T * duplicate(
        T const * const ptr,
        size_t const num)
    {
      T * const data = uninitialized<T>(num);
      for (size_t i = 0; i < num; ++i) {
        data[i] = ptr[i];
      }

      return data;
    }


    template<typename T>
    static void resize(
        T ** const ptr,
        size_t const num)
    {
      constexpr size_t const chunkSize = sizeof(T);
      T * const newPtr = reinterpret_cast<T*>( \
          std::realloc(*ptr, num*chunkSize));
      if (newPtr == nullptr) {
          throw NotEnoughMemoryException(num, chunkSize);
      }

      *ptr = newPtr;
    }


    template<typename T>
    static void free(
        T * const ptr) noexcept
    {
      if (ptr != nullptr) {
        std::free(ptr);
      }
    }
};

}


#endif