memory.hpp

Go to the documentation of this file.

 
/*
 * This file is part of Algorithms library toolkit.
 * Copyright (C) 2017 Jan Travnicek (jan.travnicek@fit.cvut.cz)
 
 * Algorithms library toolkit is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 
 * Algorithms library toolkit 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 General Public License
 * along with Algorithms library toolkit.  If not, see <http://www.gnu.org/licenses/>.
 */
 
#pragma once
 
#include <memory>
#include <utility>
#include <compare>
 
#include "type_traits.hpp"
#include "clone.hpp"
 
namespace ext {
 
template < class T >
class cow_shared_ptr : std::shared_ptr < T > {
public:
    using std::shared_ptr < T >::shared_ptr;
 
    using std::shared_ptr < T >::operator =;
 
#ifndef __clang__
    cow_shared_ptr ( const cow_shared_ptr & other ) = default;
 
    cow_shared_ptr ( cow_shared_ptr && other ) noexcept = default;
 
    ~cow_shared_ptr ( ) noexcept = default;
 
    cow_shared_ptr & operator =( const cow_shared_ptr & other ) = default;
 
    cow_shared_ptr & operator =( cow_shared_ptr && other ) noexcept = default;
#endif
 
    void reset ( ) noexcept {
        return std::shared_ptr < T >::reset ( );
    }
 
    template < class Y >
    void reset( Y * ptr ) {
        return std::shared_ptr < T >::reset ( ptr );
    }
 
    T * operator ->( ) {
        return this->get ( );
    }
 
    T const * operator ->( ) const {
        return this->get ( );
    }
 
    T & operator *( ) {
        return * this->get ( );
    }
 
    T const & operator *( ) const {
        return * this->get ( );
    }
 
    T * get ( ) {
        make_unique ( );
        return std::shared_ptr < T >::get ( );
    }
 
    T const * get ( ) const {
        return std::shared_ptr < T >::get ( );
    }
 
    bool unique ( ) const {
        return std::shared_ptr < T >::unique ( );
    }
 
    unsigned use_count ( ) const {
        return std::shared_ptr < T >::use_count ( );
    }
 
    explicit operator bool( ) const {
        return use_count ( ) != 0;
    }
 
private:
 
    void make_unique ( ) {
        if ( unique ( ) ) return;
 
        static_cast < std::shared_ptr < T > & > ( * this ) = std::shared_ptr < T > ( ext::clone ( std::shared_ptr < T >::operator * ( ) ) );
    }
 
    friend void swap ( cow_shared_ptr & first, cow_shared_ptr & second ) {
        std::swap ( static_cast < std::shared_ptr < T > & > ( first ), static_cast < std::shared_ptr < T > & > ( second ) );
    }
 
};
 
template < class T >
class smart_ptr {
    T * m_Data;
 
public:
    explicit smart_ptr ( ) : m_Data ( nullptr ) {
    }
 
    explicit smart_ptr ( T * data ) : m_Data ( data ) {
    }
 
    template < class R >
    smart_ptr ( smart_ptr < R > other ) : m_Data ( other.release ( ) ) {
    }
 
    smart_ptr ( const smart_ptr & other ) : m_Data ( ext::clone ( * other.m_Data ) ) {
    }
 
    smart_ptr ( smart_ptr && other ) noexcept : m_Data ( other.release ( ) ) {
    }
 
    ~smart_ptr ( ) noexcept {
        delete m_Data;
    }
 
    smart_ptr & operator =( const smart_ptr & other ) {
        if ( this == & other ) return * this;
 
        delete m_Data;
        m_Data = ext::clone ( * other.m_Data );
 
        return * this;
    }
 
    smart_ptr & operator =( smart_ptr && other ) noexcept {
        using std::swap;
 
        swap ( this->m_Data, other.m_Data );
        return * this;
    }
 
    T * operator ->( ) {
        return m_Data;
    }
 
    T * operator ->( ) const {
        return m_Data;
    }
 
    T & operator *( ) {
        return * m_Data;
    }
 
    T & operator *( ) const {
        return * m_Data;
    }
 
    T * get ( ) {
        return m_Data;
    }
 
    T * get ( ) const {
        return m_Data;
    }
 
    T * release ( ) {
        T * res = m_Data;
 
        m_Data = nullptr;
        return res;
    }
 
    explicit operator bool( ) const {
        return static_cast < bool > ( m_Data );
    }
 
};
 
template < class T >
std::ostream & operator <<( std::ostream & out, const ext::cow_shared_ptr < T > & ptr ) {
    out << * ptr;
    return out;
}
 
template < class T >
std::ostream & operator <<( std::ostream & out, const ext::smart_ptr < T > & ptr ) {
    out << * ptr;
    return out;
}
 
} /* namespace ext */