Pointer.hpp

Go to the documentation of this file.

/*--------------------------------------------------------------------------------------------
Copyright (c) 2019, NDEVR LLC
tyler.parke@ndevr.org
  __    __   ____     _____ __     __  _______
 |  \  |  | |  __ \  |  ___|\ \   / / |   __  \
 |   \ |  | | |  \ \ | |___  \ \ / /  |  |__)  |
 |  . \|  | | |__/ / | |___   \ V /   |   _   /
 |  |\    |_|_____/__|_____|___\_/____|  | \  \
 |__| \__________________________________|  \__\
 
Subject to the terms of the Enterprise+ Agreement, NDEVR hereby grants 
Licensee a limited, non-exclusive, non-transferable, royalty-free license 
(without the right to sublicense) to use the API solely for the purpose of 
Licensee's internal development efforts to develop applications for which 
the API was provided.
 
The above copyright notice and this permission notice shall be included in all 
copies or substantial portions of the Software.
 
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR
PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE
FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
DEALINGS IN THE SOFTWARE.
 
Library: Base
File: Pointer
Included in API: True
Author(s): Tyler Parke
 *-----------------------------------------------------------------------------------------**/
#pragma once
#include <NDEVR/ConcurrentOperation.h>
#include <NDEVR/BaseValues.h>
#include <NDEVR/LibAssert.h>
#ifdef NDEVR_USE_STD_POINTER
    #include <memory>
#endif
#ifndef NDEVR_USE_STD_POINTER
namespace NDEVR
{
    /**--------------------------------------------------------------------------------------------------
     \brief Used by Pointer to store the reference count of the pointer.
     **/
    struct PointerCore
    {
        PointerCore()
            : reference_count(1)
        {}
        volatile uint04 reference_count;
    };
 
    template< class t_other_type, class t_type>
    constexpr typename std::enable_if<std::is_polymorphic<t_type>::value, bool>::type CheckCanCast(t_type* other)
    {
        return dynamic_cast<t_other_type*>(other) != nullptr;
    }
    template<class t_other_type, class t_type>
    constexpr typename std::enable_if<!std::is_polymorphic<t_type>::value, bool>::type CheckCanCast(t_type*)
    {
        return true;
    }
 
    /**--------------------------------------------------------------------------------------------------
    \brief Provides shared ownership of a dynamically allocated object. 
    
    Weaker overall logic (Cannot detect circular references) but faster.
    **/
    template<class t_type>
    class Pointer
    {
    protected:
        Pointer() noexcept
            : m_core(nullptr)
            , m_object(nullptr)
        {}
        Pointer(t_type* value) noexcept
            : m_core(value == nullptr ? nullptr : new PointerCore())
            , m_object(value)
        {}
        Pointer(t_type&& value) noexcept
            : m_core(new PointerCore())
            , m_object(new t_type(std::move(value)))
        {}
        Pointer(const Pointer<t_type>& value) noexcept
            : m_core(value.m_core)
            , m_object(value.m_object)
        {
            if (m_core != nullptr)
                ConcurrentOperation::increment(m_core->reference_count);
        }
        t_type& get() const
        {
            lib_assert(m_object != nullptr, "Tried to access null pointer");
            return *m_object;
        }
        constexpr t_type* rawptr() const
        {
            return m_object;
        }
        void set(t_type&& value)
        {
            setToNull();
            m_core = new PointerCore();
            m_object = new t_type(std::move(value));
        }
        Pointer& operator=(const Pointer& pointer)
        {
            if (pointer.m_core == m_core)
                return *this;
            setToNull();
            m_core   = pointer.m_core;
            m_object = pointer.m_object;
            if(m_core)
                ConcurrentOperation::increment(m_core->reference_count);
            lib_assert((m_core == nullptr) == (m_object == nullptr), "Pointer core null mismatch");
            return *this;
        }
        Pointer& operator=(t_type* pointer)
        {
            setToNull();
            if (pointer)
            {
                m_core = new PointerCore();
                m_object = pointer;
            }
            lib_assert((m_core == nullptr) == (m_object == nullptr), "Pointer core null mismatch");
            return *this;
        }
        
        ~Pointer()
        {
            setToNull();
        }
    public:
        bool isNull() const { return m_object == nullptr; }
        void setToNull() 
        {
            if (m_core == nullptr)
                return;
            ConcurrentOperation::decrement(m_core->reference_count);
            if (m_core->reference_count == 0)
            {
                delete m_core;
                delete m_object;
            }
            m_core = nullptr;
            m_object = nullptr;
        }
        [[nodiscard]] uint04 referenceCount() const
        {
            if (m_core)
                return m_core->reference_count;
            else
                return 0;
        }
        bool operator==(const Pointer<t_type>& pointer) const
        {
            return pointer.m_object == m_object;
        }
        bool operator!=(const Pointer<t_type>& pointer) const
        {
            return pointer.m_object != m_object;
        }
        void swap(Pointer<t_type>& pointer)
        {
            std::swap(m_core, pointer.m_core);
            std::swap(m_object, pointer.m_object);
        }
    protected:
        PointerCore* m_core = nullptr;
        t_type* m_object = nullptr;
    };
#else
    template<class t_type>
    class Pointer
    {
        template<class T>
        friend class ConstPointer;
        template<class T>
        friend class DynamicPointer;
    protected:
        Pointer() noexcept
            : m_ptr(nullptr)
        {}
        Pointer(t_type* value) noexcept
            : m_ptr(value)
        {}
        Pointer(t_type&& value) noexcept
            :  m_ptr(new t_type(std::move(value)))
        {}
        Pointer(const Pointer<t_type>& value) noexcept
            : m_ptr(value.m_ptr)
        {
        }
        t_type& get() const
        {
            lib_assert(m_ptr != nullptr, "Tried to access null pointer");
            return *m_ptr.get();
        }
        void set(t_type&& value)
        {
            m_ptr = std::shared_ptr<t_type>(new t_type(std::move(value)));
        }
        Pointer& operator=(const Pointer& pointer)
        {
            m_ptr = pointer.m_ptr;
            return *this;
        }
        Pointer& operator=(t_type*&& pointer)
        {
            m_ptr = pointer;
            return *this;
        }
 
        ~Pointer()
        {
        }
    public:
        bool isNull() const { return m_ptr == nullptr; }
        void setToNull()
        {
            m_ptr = std::shared_ptr<t_type>();
        }
        bool operator==(const Pointer<t_type>& pointer) const
        {
            return pointer.m_ptr == m_ptr;
        }
        bool operator!=(const Pointer<t_type>& pointer) const
        {
            return pointer.m_ptr != m_ptr;
        }
        void swap(Pointer<t_type>& pointer)
        {
            std::swap(m_ptr, pointer.m_ptr);
        }
    protected:
        std::shared_ptr<t_type> m_ptr;
    };
#endif
    /**--------------------------------------------------------------------------------------------------
    \brief Provides a constant, unmodifiable pointer that has shared ownership of a dynamically allocated object.
 
    Weaker overall logic (Cannot detect circular references) but faster.
    **/
    template<class t_type>
    class ConstPointer : public Pointer<t_type>
    {
    public:
        ConstPointer()
        {}
        ConstPointer(t_type&& value) noexcept
            : Pointer<t_type>(std::move(value))
        {}
        /*ConstPointer(t_type* value) noexcept
            : Pointer<t_type>(value)
        {}*/
        ConstPointer(const t_type* value) noexcept
            : Pointer<t_type>(const_cast<t_type*>(value))
        {}
        ConstPointer(const Pointer<t_type>& value) noexcept
            : Pointer<t_type>(value)
        {}
 
        const t_type& get() const
        {
            lib_assert(!Pointer<t_type>::isNull(), "Tried to access nullptr");
            return Pointer<t_type>::get();
        }
        constexpr const t_type* rawptr() const
        {
            return Pointer<t_type>::rawptr();
        }
        void set(t_type&& value) noexcept
        {
            Pointer<t_type>::set(std::move(value));
        }
        const t_type* operator->() const
        {
            lib_assert(!Pointer<t_type>::isNull(), "Tried to access nullptr");
            return &Pointer<t_type>::get();
        }
 
        ConstPointer<t_type>& operator=(const Pointer<t_type>& pointer) noexcept
        {
            Pointer<t_type>::operator=(pointer);
            return (*this);
        }
        ConstPointer<t_type>& operator=(t_type* pointer)
        {
            Pointer<t_type>::operator=(pointer);
            return (*this);
        }
        template<class t_other_type>
        ConstPointer<t_other_type> as() const
        {
            ConstPointer<t_other_type> pointer;
#ifndef NDEVR_USE_STD_POINTER
            if (Pointer<t_type>::m_core && CheckCanCast<t_other_type>(Pointer<t_type>::m_object))
            {
                memcpy(&pointer, this, sizeof(ConstPointer<t_type>));
                ConcurrentOperation::increment(Pointer<t_type>::m_core->reference_count);
            }
#else
            pointer.m_ptr = std::dynamic_pointer_cast<t_other_type>(Pointer<t_type>::m_ptr);
#endif
            return pointer;
        }
    };
    template<class t_type, class t_index_type, bool t_null_term>
    class BufferAllocator;
 
    /**--------------------------------------------------------------------------------------------------
    \brief Provides a modifiable pointer that has shared ownership of a dynamically allocated object.
 
    Weaker overall logic (Cannot detect circular references) but faster.
    **/
    template<class t_type>
    class DynamicPointer : public ConstPointer<t_type>
    {
    public:
        DynamicPointer()
        {}
        DynamicPointer(t_type* value) noexcept
            : ConstPointer<t_type>(value)
        {}
        DynamicPointer(t_type&& value) noexcept
            : ConstPointer<t_type>(std::move(value))
        {}
        DynamicPointer(const DynamicPointer<t_type>& value) noexcept
            : ConstPointer<t_type>(value)
        {}
        DynamicPointer(DynamicPointer<t_type>&& value) noexcept
            : ConstPointer<t_type>(std::move(value))
        {}
    public:
        constexpr t_type& get() const
        {
            return Pointer<t_type>::get();
        }
        constexpr t_type* rawptr() const
        {
            return Pointer<t_type>::rawptr();
        }
 
        void set(t_type&& value)
        {
            Pointer<t_type>::set(std::move(value));
        }
        t_type* operator->() const
        {
            lib_assert(!Pointer<t_type>::isNull(), "Tried to access nullptr");
            return &Pointer<t_type>::get();
        }
 
        DynamicPointer& operator=(const DynamicPointer& pointer)
        {
            Pointer<t_type>::operator=(pointer);
            return (*this);
        }
        DynamicPointer& operator=(t_type* pointer)
        {
            Pointer<t_type>::operator=(pointer);
            return (*this);
        }
 
        template<class t_other_type>
        DynamicPointer<t_other_type> as() const
        {
            DynamicPointer<t_other_type> pointer;
#ifndef NDEVR_USE_STD_POINTER
            if (Pointer<t_type>::m_core && CheckCanCast<t_other_type>(Pointer<t_type>::m_object))
            {
                memcpy(&pointer, this, sizeof(DynamicPointer<t_type>));
                ConcurrentOperation::increment(Pointer<t_type>::m_core->reference_count);
            }
#else
            pointer.m_ptr = std::dynamic_pointer_cast<t_other_type>(Pointer<t_type>::m_ptr);
#endif
            return pointer;
        }
    };
    
}