memutils.hpp

Go to the documentation of this file.

#ifndef MEDUSA_BITS_UTILS_MEMUTILS_HPP_
#define MEDUSA_BITS_UTILS_MEMUTILS_HPP_
 
#include <memory>
#include <medusa/Config.hpp>
#include <medusa/bits/utils/assert.hpp>
 
namespace mm {
 
template <typename T>
class deep_copy_unique_ptr : public std::unique_ptr<T, std::default_delete<T>> {
  public:
    using std::unique_ptr<T, std::default_delete<T>>::unique_ptr;
    using std::unique_ptr<T, std::default_delete<T>>::operator=;
    using std::unique_ptr<T, std::default_delete<T>>::reset;
 
    explicit deep_copy_unique_ptr(const T& v) :
            std::unique_ptr<T, std::default_delete<T>>(v.clone()) {}
 
    deep_copy_unique_ptr(const deep_copy_unique_ptr& o) :
            std::unique_ptr<T, std::default_delete<T>>() {
        reset(o ? o->clone() : nullptr);
    }
 
    deep_copy_unique_ptr(deep_copy_unique_ptr&& o) noexcept :
            std::unique_ptr<T, std::default_delete<T>>(std::move(o)) { }
 
    deep_copy_unique_ptr& operator=(const T& v) {
        reset(v.clone());
        return *this;
    }
 
    deep_copy_unique_ptr& operator=(const deep_copy_unique_ptr& o) {
        reset(o ? o->clone() : nullptr);
        return *this;
    }
 
    deep_copy_unique_ptr& operator=(deep_copy_unique_ptr&& o) noexcept {
        std::unique_ptr<T, std::default_delete<T>>::operator=(std::move(o));
        return *this;
    }
};
 
std::string mem2str(std::size_t bytes);
 
template<typename container_t>
std::size_t mem_used(const container_t& v) {
    return sizeof(v[0]) * v.size();
}
 
}  // namespace mm
 
#endif  // MEDUSA_BITS_UTILS_MEMUTILS_HPP_