managed_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 <compare>
 
namespace ext {
 
template < class T >
class managed_value {
    T m_data;
 
    std::vector < std::function < void ( const T & ) > > changeCallbacks;
 
    void fireChange ( const T & element ) {
        for ( const std::function < void ( const T & ) > & callback : changeCallbacks ) {
            callback ( element );
        }
    }
 
public:
    void addChangeCallback ( const std::function < void ( const T & ) > & callback ) {
        changeCallbacks.push_back ( callback );
    }
 
    typedef T value_type;
 
    managed_value ( const T & value ) : m_data ( value ) {
    }
 
    managed_value ( T && value ) : m_data ( std::move ( value ) ) {
    }
 
    managed_value ( const managed_value & x ) : m_data ( x.m_data ) {
    }
 
    managed_value ( managed_value && x ) : m_data ( std::move ( x.m_data ) ) {
    }
 
    ~managed_value ( ) {
    }
 
    managed_value & operator= ( const managed_value & x ) {
        m_data = x.m_data;
        fireChange ( m_data );
        return *this;
    }
 
    managed_value& operator= ( managed_value && x ) {
        m_data = std::move ( x.m_data );
        fireChange ( m_data );
        return *this;
    }
 
    void swap ( managed_value & x ) {
        // intentionally swaped values the change fired is before its execution
        this->fireChange ( x.getValue ( ) );
        x.fireChange ( this->getValue ( ) );
 
        using std::swap;
        swap ( m_data, x.m_data );
    }
 
    auto operator <=> ( const managed_value < T > & other ) const = default;
 
};
 
template < class T >
void swap ( ext::managed_value < T > & x, ext::managed_value < T > & y) {
    x.swap ( y );
}
 
template< class T >
std::ostream & operator << ( std::ostream & out, const ext::managed_value < T > & value ) {
    out << value.getValue ( );
    return out;
}
 
} /* namespace ext */