irr_ptr.h

Go to the documentation of this file.

/*
Minetest
Copyright (C) 2018 numzero, Lobachevskiy Vitaliy <numzer0@yandex.ru>
 
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU Lesser General Public License as published by
the Free Software Foundation; either version 2.1 of the License, or
(at your option) any later version.
 
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 Lesser General Public License for more details.
 
You should have received a copy of the GNU Lesser General Public License along
with this program; if not, write to the Free Software Foundation, Inc.,
51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
*/
 
#pragma once
#include <type_traits>
#include <utility>
#include "irrlichttypes.h"
#include "IReferenceCounted.h"
 
template <class ReferenceCounted,
                class = typename std::enable_if<std::is_base_of<IReferenceCounted,
                                ReferenceCounted>::value>::type>
class irr_ptr
{
        ReferenceCounted *value = nullptr;
 
public:
        irr_ptr() {}
 
        irr_ptr(std::nullptr_t) noexcept {}
 
        irr_ptr(const irr_ptr &b) noexcept { grab(b.get()); }
 
        irr_ptr(irr_ptr &&b) noexcept { reset(b.release()); }
 
        template <typename B, class = typename std::enable_if<std::is_convertible<B *,
                                              ReferenceCounted *>::value>::type>
        irr_ptr(const irr_ptr<B> &b) noexcept
        {
                grab(b.get());
        }
 
        template <typename B, class = typename std::enable_if<std::is_convertible<B *,
                                              ReferenceCounted *>::value>::type>
        irr_ptr(irr_ptr<B> &&b) noexcept
        {
                reset(b.release());
        }
 
        explicit irr_ptr(ReferenceCounted *object) noexcept { reset(object); }
 
        ~irr_ptr() { reset(); }
 
        irr_ptr &operator=(const irr_ptr &b) noexcept
        {
                grab(b.get());
                return *this;
        }
 
        irr_ptr &operator=(irr_ptr &&b) noexcept
        {
                reset(b.release());
                return *this;
        }
 
        template <typename B, class = typename std::enable_if<std::is_convertible<B *,
                                              ReferenceCounted *>::value>::type>
        irr_ptr &operator=(const irr_ptr<B> &b) noexcept
        {
                grab(b.get());
                return *this;
        }
 
        template <typename B, class = typename std::enable_if<std::is_convertible<B *,
                                              ReferenceCounted *>::value>::type>
        irr_ptr &operator=(irr_ptr<B> &&b) noexcept
        {
                reset(b.release());
                return *this;
        }
 
        ReferenceCounted &operator*() const noexcept { return *value; }
        ReferenceCounted *operator->() const noexcept { return value; }
        explicit operator ReferenceCounted *() const noexcept { return value; }
        explicit operator bool() const noexcept { return !!value; }
 
        ReferenceCounted *get() const noexcept { return value; }
 
        ReferenceCounted *release() noexcept
        {
                ReferenceCounted *object = value;
                value = nullptr;
                return object;
        }
 
        void reset(ReferenceCounted *object = nullptr) noexcept
        {
                if (value)
                        value->drop();
                value = object;
        }
 
        void grab(ReferenceCounted *object) noexcept
        {
                if (object)
                        object->grab();
                reset(object);
        }
};
 
template <class ReferenceCounted>
irr_ptr<ReferenceCounted> grab(ReferenceCounted *object) noexcept
{
        irr_ptr<ReferenceCounted> ptr;
        ptr.grab(object);
        return ptr;
}
 
template <typename ReferenceCounted>
bool operator==(const irr_ptr<ReferenceCounted> &a, const irr_ptr<ReferenceCounted> &b) noexcept
{
        return a.get() == b.get();
}
 
template <typename ReferenceCounted>
bool operator==(const irr_ptr<ReferenceCounted> &a, const ReferenceCounted *b) noexcept
{
        return a.get() == b;
}
 
template <typename ReferenceCounted>
bool operator==(const ReferenceCounted *a, const irr_ptr<ReferenceCounted> &b) noexcept
{
        return a == b.get();
}
 
template <typename ReferenceCounted>
bool operator!=(const irr_ptr<ReferenceCounted> &a, const irr_ptr<ReferenceCounted> &b) noexcept
{
        return a.get() != b.get();
}
 
template <typename ReferenceCounted>
bool operator!=(const irr_ptr<ReferenceCounted> &a, const ReferenceCounted *b) noexcept
{
        return a.get() != b;
}
 
template <typename ReferenceCounted>
bool operator!=(const ReferenceCounted *a, const irr_ptr<ReferenceCounted> &b) noexcept
{
        return a != b.get();
}
 
template <class T, class... Args>
irr_ptr<T> make_irr(Args&&... args)
{
        return irr_ptr<T>(new T(std::forward<Args>(args)...));
}