mn_any.hpp

Go to the documentation of this file.

/*
*This file is part of the Mini Thread Library (https://github.com/RoseLeBlood/MiniThread ).
*Copyright (c) 2018 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 __MINILIB_CONTAINER_ANY_H__
#define __MINILIB_CONTAINER_ANY_H__
 
#include "../mn_config.hpp"
 
# include <cassert>
# include <typeinfo>
 
#include "mn_algorithm.hpp"
#include "../mn_allocator.hpp"
#include "../mn_def.hpp"
#include "../mn_functional.hpp"
#include "../mn_typetraits.hpp"
 
#include "../utils/mn_utils.hpp"
 
 
 
namespace mn {
    namespace container {
        class basic_any {
            class basic_any_holder {
            public:
                virtual std::type_info const & type() const = 0;
                virtual iholder * clone() const = 0;
            };
 
            template< typename T >
            class basic_any_holder_impl : public basic_any_holder {
            public:
                static const int TYPE_SIZE() { return sizeof(T); }
 
                basic_any_holder_impl( T const & value ) : m_typeHold( value ) {}
                basic_any_holder_impl( T && value ) : m_typeHold( mn::move( value ) ) {}
 
 
                virtual std::type_info const & type() const override {
                    return typeid( T );
                }
 
                virtual basic_any_holder* clone() const override {
                    return new basic_any_holder_impl( m_typeHold );
                }
 
                T get() { return m_typeHold; }
                const T get() const { return m_typeHold; }
 
                operator T() { return get(); }
            private:
                T m_typeHold;
            };
 
        public:
            using self_type = basic_any<TAllocator>;
            using holder_type = basic_any_holder;
 
            constexpr basic_any() noexcept
                : m_asyContent( nullptr ) {}
 
            template< class T >
            basic_any(const T & other ) : m_asyContent( nullptr ) {
                construct(other);
            }
 
            basic_any( const self_type& other )
                : m_asyContent(nullptr )  {
                    if ((this != &other) && !other.empty()) construct(other);
            }
 
            basic_any( self_type && other ) noexcept
                : m_asyContent.content( mn::move( other.m_asyContent ) ) {
                    other.m_asyContent = nullptr;
            }
 
            ~basic_any() { deconstruct(true); }
 
            void reset() noexcept {
                deconstruct(false);
            }
 
            self_type& swap( any & other ) noexcept {
                if (this == &other) return *this;
 
                mn::swap( m_asyContent, other.m_asyContent );
                return *this;
            }
 
            bool has_value() const noexcept {
                return m_asyContent != nullptr;
            }
 
            bool is_empty() const noexcept {
                return m_asyContent == nullptr;
            }
 
            const std::type_info & type() const noexcept {
                return has_value() ? m_asyContent->type() : typeid( void );
            }
 
            template<class T>
            const T * to_pointer() const {
                auto* _content = static_cast<basic_any_holder_impl<T> *>( m_asyContent );
                return &( _content->get() );
            }
 
            template< class T >
            T * to_pointer() {
                auto* _content = static_cast<basic_any_holder_impl<T> *>( m_asyContent );
                return &( _content->get() );
            }
 
            self_type& operator=( const self_type& other ) noexcept {
                self_type( other ).swap( *this );
                return *this;
            }
 
            self_type& operator=( self_type && other ) noexcept {
                self_type( mn::move( other ) ).swap( *this );
                return *this;
            }
 
            template<typename T>
            self_type& operator=(const T& other ) noexcept {
                construct(other);
                return *this;
            }
 
            template< class T, class... Args >
            void emplace( Args && ... args ) {
                self_type( T( mn::forward<Args>(args)... ) ).swap( *this );
            }
        private:
            void construct(const self_type& other) {
                if(other.has_value())
                    m_asyContent = other.m_asyContent->clone() ;
                else
                    m_asyContent = nullptr;
            }
 
            template< class T >
            void construct(const T & other) {
                m_asyContent = new  basic_any_holder_impl<T>(other) ;
            }
 
            void deconstruct(bool bdelete = false) {
                mn::destruct<content_type>(m_asyContent);
                if(bdelete) delete m_asyContent;
            }
        private:
            holder_type m_asyContent;
        };
 
        inline void swap( basic_any& x, basic_any& y ) noexcept {
            x.swap( y );
        }
 
        template< class T, class ...Args >
        inline basic_any make_any( Args&& ...args ) {
            return basic_any( mn::in_place_type<T>, mn::forward<Args>(args)...);
        }
 
        template< class T >
        inline const T* any_cast( const basic_any* other ) noexcept {
            if(other == nullptr) return nullptr;
            return operand->type() == typeid(T) ? operand->to_pointer<T>() : nullptr;
        }
 
        template<class T >
        inline T* any_cast(basic_any* other ) noexcept {
            if(other == nullptr) return nullptr;
            return operand->type() == typeid(T) ? operand->to_pointer<T>() : nullptr;
        }
    }
}
#endif // __MINILIB_CONTAINER_ANY_H__