memory.hpp

Go to the documentation of this file.

/* 
 * This file is part of PLaSK (https://plask.app) by Photonics Group at TUL
 * Copyright (c) 2022 Lodz University of Technology
 * 
 * This program 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, version 3.
 *
 * This program 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.
 */
#ifndef PLASK__MEMORY_H
#define PLASK__MEMORY_H
 
#include <plask/config.hpp>
 
#ifdef PLASK_SHARED_PTR_STD
 
#include <memory>
namespace plask {
    using std::shared_ptr;
    using std::make_shared;
    using std::dynamic_pointer_cast;
    using std::static_pointer_cast;
    using std::const_pointer_cast;
    using std::weak_ptr;
    using std::enable_shared_from_this;
}
 
#else // PLASK_SHARED_PTR_STD
// Use boost::shared_ptr
 
#define BOOST_BIND_GLOBAL_PLACEHOLDERS
 
#include <boost/shared_ptr.hpp>
#include <boost/make_shared.hpp>
#include <boost/weak_ptr.hpp>
#include <boost/enable_shared_from_this.hpp>
namespace plask {
    using boost::shared_ptr;
    using boost::make_shared;
    using boost::dynamic_pointer_cast;
    using boost::static_pointer_cast;
    using boost::const_pointer_cast;
    using boost::weak_ptr;
    using boost::enable_shared_from_this;
}
 
#endif // PLASK_SHARED_PTR_STD
 
 
namespace plask {
template <typename T>
struct Holder {
 
    protected:
 
    T* held;
 
    public:
 
    Holder(T* held) noexcept: held(held) {}
 
    Holder(T& held) noexcept: held(&held) {}
 
    Holder(const Holder<T>& to_copy): held(to_copy.held->clone()) {}
 
    Holder(Holder<T>&& to_move) noexcept: held(to_move.held) { to_move.held = nullptr; }
 
    Holder<T>& operator=(const Holder& to_copy) {
        if (held == to_copy.held) return *this;   //self-assignment protection
        delete held;
        held = to_copy.held->clone();
        return *this;
    }
 
    Holder<T>& operator=(Holder&& to_move) noexcept {
        std::swap(held, to_move.held);  // to_move destructor will delete this old held for a moment
        return *this;
    }
 
    ~Holder() { delete held; }
 
};
 
template <typename T>
struct HolderRef {
 
    protected:
 
    shared_ptr<T> held;
 
    public:
 
    HolderRef() {}
 
    HolderRef(T* held): held(held) {}
 
    bool isNotNull() const { return held != nullptr; }
 
    bool isNull() const { return !held; }
 
    void reset(T* new_held) { this->held.reset(new_held); }
 
};
 
template <typename T>
inline shared_ptr<T> getUnique(const shared_ptr<T>& ptr) {
    return ptr.unique() ? ptr : new T(*ptr);
}
 
template <typename T>
inline shared_ptr<T> getUnique(const shared_ptr<const T>& ptr) {
    return ptr.unique() ? ptr : new T(*ptr);
}
 
template <typename T>
inline void makeUnique(shared_ptr<T>& ptr) {
    ptr = getUnique(ptr);
}
 
}   // namespace plask
 
#endif // PLASK__MEMORY_H