mn_linked_ptr.hpp

Go to the documentation of this file.

/*
*This file is part of the Mini Thread Library (https://github.com/RoseLeBlood/MiniThread ).
*Copyright (c) 2021 Amber-Sophia Schroeck
*
*The Mini Thread Library 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, version 3, or (at your option) any later version.
 
*The Mini Thread Library 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.
*
*You should have received a copy of the GNU Lesser General Public
*License along with the Mini Thread  Library; if not, see
*<https://www.gnu.org/licenses/>.
*/
#ifndef MINLIB_ee040f46_b480_4f16_a0f8_c6765774ff00_H_
#define MINLIB_ee040f46_b480_4f16_a0f8_c6765774ff00_H_
 
#include "../mn_config.hpp"
 
#include "../mn_def.hpp"
 
namespace mn {
    namespace pointer {
 
        struct basic_linked_ptr_node  {
            mutable basic_linked_ptr_node* Prev;
            mutable basic_linked_ptr_node* Next;
        };
 
        template <typename T >
        class basic_linked_ptr : public basic_linked_ptr_node {
            template <typename U> friend class basic_linked_ptr;
        public:
            using self_type = basic_linked_ptr<T>;
            using value_type = T;
            using element_type = T;
            using reference = T&;
            using pointer = T*;
            using base_type = basic_linked_ptr_node;
 
            basic_linked_ptr()
                : m_pValue(nullptr) { Prev = Next = this; }
            explicit basic_linked_ptr(pointer pValue)
                : m_pValue(pValue) { Prev = Next = this; }
 
            basic_linked_ptr(const basic_linked_ptr& _pPtr) : m_pValue(_pPtr.m_pValue) {
                if(m_pValue) link(_pPtr);
                else Prev = Next = this;
            }
 
            template <typename U>
            basic_linked_ptr(const basic_linked_ptr<U>& _pPtr)
                : m_pValue(_pPtr.m_pValue) {
                    if(m_pValue) link(_pPtr);
                    else Prev = Next = this;
            }
            ~basic_linked_ptr() { reset(); }
 
 
            void reset() { reset(nullptr); }
            pointer get() { return m_pValue; }
 
            void force_delete() { pointer _pValue = detach(); delete _pValue; }
 
 
            int count() const {
                int _count = 1;
 
                for(const base_type* _pCurrent = static_cast<const base_type*>(this);
                        _pCurrent->Next != static_cast<const base_type*>(this);
                        _pCurrent = _pCurrent->Next) {
                    ++_count;
                }
 
                return _count;
            }
 
            pointer detach() {
                T* _pValue = m_pValue;
                base_type* _p = this;
 
                do {
                    base_type* _pNext = _p->Next;
                    static_cast<self_type*>(_p)->m_pValue = 0;
 
                    _p->Next = _p->Prev = _p;
                    _p = _pNext;
                }
                while(_p != this);
 
                return _pValue;
            }
 
 
            bool unique() { return (Next == static_cast<const base_type*>(this)); }
 
            basic_linked_ptr& operator = (const basic_linked_ptr& _pPtr) {
                if(_pPtr.m_pValue != m_pValue) {
                    reset(_pPtr.m_pValue);
                    if(_pPtr.m_pValue)
                        link(_pPtr);
                }
                return *this;
            }
 
            reference operator*() { return *m_pValue; }
            pointer operator->()  { return m_pValue; }
            operator bool ()      { return (m_pValue != 0); }
 
        public:
            template <typename U>
            void reset(U* pValue) {
                if(pValue != m_pValue) {
                    if(unique()) {
                        delete m_pValue;
                    }
                    else {
                        Prev->Next  = Next;
                        Next->Prev  = Prev;
                        Prev = Next = this;
                    }
                    m_pValue = pValue;
                }
            }
 
            template <typename U>
            basic_linked_ptr& operator = (const basic_linked_ptr<U>& _pPtr) {
                if(_pPtr.m_pValue != m_pValue) {
                    reset(_pPtr.m_pValue);
                    if(_pPtr.m_pValue)
                        link(_pPtr);
                }
                return *this;
            }
            template <typename U>
            basic_linked_ptr& operator = (U* pValue) {
                reset(pValue);
                return *this;
            }
        protected:
            template <typename U>
            void link(const basic_linked_ptr<U>& pOther) {
                Next           = pOther.mpNext;
                Prev           = this;
                Prev           = const_cast<basic_linked_ptr<U>*>(&pOther);
                pOther.Next    = this;
            }
        protected:
            pointer m_pValue;
        };
 
        template <typename T >
        inline basic_linked_ptr<T>  make_link(const basic_linked_ptr<T>& value) {
            return basic_linked_ptr<T>(value);
        }
 
        template <typename T, typename U  >
        inline basic_linked_ptr<T>  make_link(const basic_linked_ptr<U>& value) {
            return basic_linked_ptr<T>(value);
        }
 
        template <typename T>
        inline basic_linked_ptr<T>  make_link(T* value) {
            return basic_linked_ptr<T>(value);
        }
 
 
        template <typename T>
        inline T* get(const basic_linked_ptr<T>& _pPtr) {
            return _pPtr.get();
        }
        template <typename T, typename U>
        inline bool operator==(const basic_linked_ptr<T>& a, const basic_linked_ptr<U>& b) {
            return (a.get() == b.get());
        }
 
        template <typename T, typename U>
        inline bool operator!=(const basic_linked_ptr<T>& a, const basic_linked_ptr<U>& b) {
            return (a.get() != b.get());
        }
 
        template <typename T>
        using linked_ptr = basic_linked_ptr<T>;
 
    }
}
 
#endif