property.h

Go to the documentation of this file.

/*
  This file is part of KDBindings.
 
  SPDX-FileCopyrightText: 2021 Klarälvdalens Datakonsult AB, a KDAB Group company <info@kdab.com>
  Author: Sean Harmer <sean.harmer@kdab.com>
 
  SPDX-License-Identifier: MIT
 
  Contact KDAB at <info@kdab.com> for commercial licensing options.
*/
 
#pragma once
 
#include <kdbindings/property_updater.h>
#include <kdbindings/signal.h>
 
#include <iostream>
#include <memory>
#include <type_traits>
 
namespace KDBindings {
 
namespace Private {
 
template<typename X, typename Y, typename = void>
struct are_equality_comparable : std::false_type {
};
 
template<typename X, typename Y>
struct are_equality_comparable<X, Y,
                               std::enable_if_t<
                                       std::is_same<
                                               std::decay_t<
                                                       decltype(std::equal_to<>{}(std::declval<X>(), std::declval<Y>()))>,
                                               bool>::value>> : std::true_type {
};
 
template<typename X, typename Y>
constexpr bool are_equality_comparable_v = are_equality_comparable<X, Y>::value;
 
} // namespace Private
 
struct ReadOnlyProperty : std::runtime_error {
    ReadOnlyProperty() = delete;
 
    using std::runtime_error::runtime_error;
};
 
template<typename T>
struct equal_to {
    auto operator()(const T &x, const T &y) const noexcept
            -> std::enable_if_t<Private::are_equality_comparable_v<T, T>, bool>
    {
        return std::equal_to<>{}(x, y);
    }
 
    template<typename X, typename Y>
    auto operator()(const X &, const Y &) const noexcept
            -> std::enable_if_t<!Private::are_equality_comparable_v<X, Y>, bool>
    {
        return false;
    }
};
 
// This forwrad declaration is required so that
// Property can declare PropertyNode as a friend
// class.
namespace Private {
template<typename PropertyType>
class PropertyNode;
}
 
template<typename T>
class Property
{
public:
    typedef T valuetype;
 
    Property() = default;
 
    ~Property()
    {
        m_destroyed.emit();
    }
 
    explicit Property(T value) noexcept(std::is_nothrow_move_constructible<T>::value)
        : m_value{ std::move(value) }
    {
    }
 
    Property(Property<T> const &other) = delete;
    Property &operator=(Property<T> const &other) = delete;
 
    Property(Property<T> &&other) noexcept(std::is_nothrow_move_constructible<T>::value)
        : m_value(std::move(other.m_value))
        , m_valueAboutToChange(std::move(other.m_valueAboutToChange))
        , m_valueChanged(std::move(other.m_valueChanged))
        , m_destroyed(std::move(other.m_destroyed))
        , m_updater(std::move(other.m_updater))
    {
        // We do not move the m_moved signal yet so that objects interested in the moved-into
        // property can recreate any connections they need.
 
        // If we have an updater, let it know how to update our internal value
        if (m_updater) {
            using namespace std::placeholders;
            m_updater->setUpdateFunction(
                    std::bind(&Property<T>::setHelper, this, _1));
        }
 
        // Emit the moved signals for the moved from and moved to properties
        m_moved.emit(*this);
        other.m_moved.emit(*this);
        m_moved = std::move(other.m_moved);
    }
 
    Property &operator=(Property<T> &&other) noexcept(std::is_nothrow_move_assignable<T>::value)
    {
        // We do not move the m_moved signal yet so that objects interested in the moved-into
        // property can recreate any connections they need.
        m_value = std::move(other.m_value);
        m_valueAboutToChange = std::move(other.m_valueAboutToChange);
        m_valueChanged = std::move(other.m_valueChanged);
        m_destroyed = std::move(other.m_destroyed);
        m_updater = std::move(other.m_updater);
 
        // If we have an updater, let it know how to update our internal value
        if (m_updater) {
            using namespace std::placeholders;
            m_updater->setUpdateFunction(
                    std::bind(&Property<T>::setHelper, this, _1));
        }
 
        // Emit the moved signals for the moved from and moved to properties
        m_moved.emit(*this);
        other.m_moved.emit(*this);
        m_moved = std::move(other.m_moved);
 
        return *this;
    }
 
    template<typename UpdaterT>
    explicit Property(std::unique_ptr<UpdaterT> &&updater)
    {
        *this = std::move(updater);
    }
 
    template<typename UpdaterT>
    Property &operator=(std::unique_ptr<UpdaterT> &&updater)
    {
        m_updater = std::move(updater);
 
        // Let the updater know how to update our internal value
        using namespace std::placeholders;
        m_updater->setUpdateFunction(
                std::bind(&Property<T>::setHelper, this, _1));
 
        // Now synchronise our value with whatever the updator has right now.
        setHelper(m_updater->get());
 
        return *this;
    }
 
    void reset()
    {
        m_updater.reset();
    }
 
    Signal<const T &, const T &> &valueAboutToChange() const { return m_valueAboutToChange; }
 
    Signal<const T &> &valueChanged() const { return m_valueChanged; }
 
    Signal<> &destroyed() const { return m_destroyed; }
 
    bool hasBinding() const noexcept { return m_updater.get() != nullptr; }
 
    void set(T value)
    {
        if (m_updater) {
            throw ReadOnlyProperty{
                "Cannot set value on a read-only property. This property likely holds the result of a binding expression."
            };
        }
        setHelper(std::move(value));
    }
 
    T const &get() const
    {
        return m_value;
    }
 
    Property<T> &operator=(T const &rhs)
    {
        set(std::move(rhs));
        return *this;
    }
 
    T const &operator()() const
    {
        return Property<T>::get();
    }
 
private:
    void setHelper(T value)
    {
        if (equal_to<T>{}(value, m_value))
            return;
 
        m_valueAboutToChange.emit(m_value, value);
        m_value = std::move(value);
        m_valueChanged.emit(m_value);
    }
 
    T m_value;
    // the signals in a property are mutable, as a property
    // being "const" should mean that it's value or binding does
    // not change, not that nobody can listen to it anymore.
    mutable Signal<const T &, const T &> m_valueAboutToChange;
    mutable Signal<const T &> m_valueChanged; // By const ref so we can emit the signal for move-only types of T e.g. std::unique_ptr<int>
 
    // The PropertyNode needs to be a friend class of the Property, as it needs
    // access to the m_moved Signal.
    // The decision to make this Signal private was made after the suggestion by
    // @jm4R who reported issues with the move constructors noexcept guarantee.
    // (https://github.com/KDAB/KDBindings/issues/24)
    // Ideally we would like to figure out a way to remove the moved signal entirely
    // at some point. However currently it is still needed for Property bindings to
    // keep track of moved Properties.
    template<typename PropertyType>
    friend class Private::PropertyNode;
    mutable Signal<Property<T> &> m_moved;
 
    mutable Signal<> m_destroyed;
    std::unique_ptr<PropertyUpdater<T>> m_updater;
};
 
template<typename T>
std::ostream &operator<<(std::ostream &stream, Property<T> const &property)
{
    stream << property.get();
    return stream;
}
 
template<typename T>
std::istream &operator>>(std::istream &stream, Property<T> &prop)
{
    T temp;
    stream >> temp;
    prop.set(std::move(temp));
    return stream;
}
 
namespace Private {
 
template<typename T>
struct is_property_helper : std::false_type {
};
 
template<typename T>
struct is_property_helper<Property<T>> : std::true_type {
};
 
template<typename T>
struct is_property : is_property_helper<std::decay_t<T>> {
};
 
} // namespace Private
 
} // namespace KDBindings