mn_any_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_de6432e5_32f4_4ce2_bec3_0a8f4e20a0f4_H_
#define MINLIB_de6432e5_32f4_4ce2_bec3_0a8f4e20a0f4_H_
 
#include "../mn_config.hpp"
 
#include "../mn_def.hpp"
 
namespace mn {
    namespace pointer {
 
        template <typename T>
        class basic_any_ptr  {
        public:
            using element_type = T;
            using size_type = size_t;
            using pointer = T*;
            using const_pointer = const T*;
            using self_type = basic_any_ptr<T>;
 
            // Default Constructor
 
            basic_any_ptr() : m_pObject(nullptr) { }
            basic_any_ptr(const_pointer pObject)
                : m_pObject( const_cast<const_pointer>(m_pObject) ) { }
 
            basic_any_ptr(const basic_any_ptr& other)
                : m_pObject( const_cast<const_pointer>(other.m_pObject) ) { }
 
            template <typename U>
            basic_any_ptr(const basic_any_ptr<U>& other)
                : m_pObject( const_cast<const_pointer>(other.m_pObject) ) { }
 
            const self_type& operator = (const self_type &other) {
                m_pObject = const_cast<const_pointer>(other.m_pObject);
                return *this;
            }
 
            template <class U>
            const self_type &operator = (const basic_any_ptr<U> &other) {
                m_pObject = const_cast<const_pointer>(other.m_pObject); return *this;
            }
 
            template <class U>
            const self_type& operator = (const U* pObject) {
                m_pObject = const_cast<const_pointer>(m_pObject);
                return (*this);
            }
 
            operator const_pointer() { return static_cast<T*>( m_pObject ); }
 
 
            template <class U>
            operator const U*()             { return static_cast<U*>( m_pObject ); }
 
            bool is_null()     { return (m_pObject == 0); }
 
        private:
            const_pointer m_pObject;
        };
 
        using any_ptr = basic_any_ptr<void>;
    }
}
 
#endif