ptr_value.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 <extensions/iterator.hpp>
#include <extensions/clone.hpp>
 
namespace ext {
 
template < class T >
class ptr_value {
    T * m_data;
 
public:
    explicit ptr_value ( const T & value ) : m_data ( ext::clone ( value ) ) {
 
    }
 
    explicit ptr_value ( T && value ) : m_data ( ext::clone ( std::forward < T > ( value ) ) ) {
 
    }
 
    template < class U >
    ptr_value ( ptr_value < U > && other ) : m_data ( other.m_data ) {
        other.m_data = nullptr;
    }
 
    ptr_value ( const ptr_value & other ) : m_data ( ext::clone ( other.m_data ) ) {
 
    }
 
    ptr_value ( ptr_value && other ) noexcept : m_data ( other.m_data ) {
        other.m_data = nullptr;
    };
 
    ptr_value & operator = ( const ptr_value & other ) {
        if ( this == & other )
            return *this;
 
        delete m_data;
        m_data = ext::clone ( other.m_data );
        return * this;
    }
 
    ptr_value & operator = ( ptr_value && other ) noexcept {
        using std::swap;
 
        swap ( m_data, other.m_data );
 
        return *this;
    }
 
    ~ptr_value ( ) noexcept {
        delete m_data;
    }
 
    T * operator ->( ) && {
        return m_data;
    }
 
    T * operator ->( ) & {
        return m_data;
    }
 
    const T * operator ->( ) const & {
        return m_data;
    }
 
    operator T & ( ) & {
        return * m_data;
    }
 
    operator const T && ( ) const & {
        return std::move ( * m_data );
    }
 
    operator T && ( ) && {
        return std::move ( * m_data );
    }
 
    const T & get ( ) const {
        return * m_data;
    }
 
    template < class U >
    friend class ptr_value;
};
 
} /* namespace ext */