Binding.h

#pragma once
 
#include "INotifyObjectDead.h"
#include "INotifyPropertyChanged.h"
#include "IValueConverter.h"
 
namespace sw
{
    enum class BindingMode {
        OneTime,
 
        OneWay,
 
        OneWayToSource,
 
        TwoWay,
    };
 
    class BindingBase
    {
    public:
        virtual ~BindingBase() = default;
 
    public:
        virtual bool UpdateTarget() = 0;
 
        virtual bool UpdateSource() = 0;
 
        virtual FieldId GetTargetPropertyId() const = 0;
 
        virtual FieldId GetSourcePropertyId() const = 0;
    };
 
    class Binding final : public BindingBase
    {
    private:
        BindingMode _mode;
 
        DynamicObject *_targetObject;
 
        DynamicObject *_sourceObject;
 
        FieldId _targetPropertyId;
 
        FieldId _sourcePropertyId;
 
        void *_converter;
 
        void (*_converterDeleter)(void *);
 
        Func<Binding *, bool> _updateTargetFunc;
 
        Func<Binding *, bool> _updateSourceFunc;
 
    private:
        Binding() = default;
 
        Binding(const Binding &)            = delete; // 删除拷贝构造函数
        Binding(Binding &&)                 = delete; // 删除移动构造函数
        Binding &operator=(const Binding &) = delete; // 删除拷贝赋值运算符
        Binding &operator=(Binding &&)      = delete; // 删除移动赋值运算符
 
    public:
        virtual ~Binding()
        {
            UnregisterNotifications();
 
            if (_converterDeleter && _converter) {
                _converterDeleter(_converter);
            }
        }
 
        virtual bool UpdateTarget() override
        {
            bool result = false;
 
            if (_updateTargetFunc) {
                result = _updateTargetFunc(this);
            }
            return result;
        }
 
        virtual bool UpdateSource() override
        {
            bool result = false;
 
            if (_updateSourceFunc) {
                result = _updateSourceFunc(this);
            }
            return result;
        }
 
        virtual FieldId GetTargetPropertyId() const override
        {
            return _targetPropertyId;
        }
 
        virtual FieldId GetSourcePropertyId() const override
        {
            return _sourcePropertyId;
        }
 
        BindingMode GetBindingMode() const
        {
            return _mode;
        }
 
        DynamicObject *GetTargetObject() const
        {
            return _targetObject;
        }
 
        DynamicObject *GetSourceObject() const
        {
            return _sourceObject;
        }
 
        void SetBindingMode(BindingMode mode)
        {
            if (_mode != mode) {
                _mode = mode;
                OnBindingChanged();
            }
        }
 
        void SetTargetObject(DynamicObject *target)
        {
            if (_targetObject != target) {
                UnregisterNotifications();
                _targetObject = target;
                RegisterNotifications();
                OnBindingChanged();
            }
        }
 
        void SetSourceObject(DynamicObject *source)
        {
            if (_sourceObject != source) {
                UnregisterNotifications();
                _sourceObject = source;
                RegisterNotifications();
                OnBindingChanged();
            }
        }
 
        void SetBindingObjects(DynamicObject *target, DynamicObject *source)
        {
            if (_targetObject != target ||
                _sourceObject != source) //
            {
                UnregisterNotifications();
                _targetObject = target;
                _sourceObject = source;
                RegisterNotifications();
                OnBindingChanged();
            }
        }
 
    private:
        void RegisterNotifications()
        {
            INotifyPropertyChanged *targetNotifObj = nullptr;
            INotifyPropertyChanged *sourceNotifObj = nullptr;
 
            if (_targetObject != nullptr && _targetObject->IsType(&targetNotifObj)) {
                targetNotifObj->PropertyChanged +=
                    PropertyChangedEventHandler(*this, &Binding::OnTargetPropertyChanged);
            }
            if (_sourceObject != nullptr && _sourceObject->IsType(&sourceNotifObj)) {
                sourceNotifObj->PropertyChanged +=
                    PropertyChangedEventHandler(*this, &Binding::OnSourcePropertyChanged);
            }
 
            INotifyObjectDead *targetNotifObjDead = nullptr;
            INotifyObjectDead *sourceNotifObjDead = nullptr;
 
            if (_targetObject != nullptr && _targetObject->IsType(&targetNotifObjDead)) {
                targetNotifObjDead->ObjectDead +=
                    ObjectDeadEventHandler(*this, &Binding::OnTargetObjectDead);
            }
            if (_sourceObject != nullptr && _sourceObject->IsType(&sourceNotifObjDead)) {
                sourceNotifObjDead->ObjectDead +=
                    ObjectDeadEventHandler(*this, &Binding::OnSourceObjectDead);
            }
        }
 
        void UnregisterNotifications()
        {
            INotifyPropertyChanged *targetNotifObj = nullptr;
            INotifyPropertyChanged *sourceNotifObj = nullptr;
 
            if (_targetObject != nullptr && _targetObject->IsType(&targetNotifObj)) {
                targetNotifObj->PropertyChanged -=
                    PropertyChangedEventHandler(*this, &Binding::OnTargetPropertyChanged);
            }
            if (_sourceObject != nullptr && _sourceObject->IsType(&sourceNotifObj)) {
                sourceNotifObj->PropertyChanged -=
                    PropertyChangedEventHandler(*this, &Binding::OnSourcePropertyChanged);
            }
 
            INotifyObjectDead *targetNotifObjDead = nullptr;
            INotifyObjectDead *sourceNotifObjDead = nullptr;
 
            if (_targetObject != nullptr && _targetObject->IsType(&targetNotifObjDead)) {
                targetNotifObjDead->ObjectDead -=
                    ObjectDeadEventHandler(*this, &Binding::OnTargetObjectDead);
            }
            if (_sourceObject != nullptr && _sourceObject->IsType(&sourceNotifObjDead)) {
                sourceNotifObjDead->ObjectDead -=
                    ObjectDeadEventHandler(*this, &Binding::OnSourceObjectDead);
            }
        }
 
        void OnTargetPropertyChanged(INotifyPropertyChanged &sender, FieldId propertyId)
        {
            if (propertyId != _targetPropertyId) {
                return;
            }
 
            if (_mode == BindingMode::TwoWay ||
                _mode == BindingMode::OneWayToSource) {
                UpdateSource();
            }
        }
 
        void OnSourcePropertyChanged(INotifyPropertyChanged &sender, FieldId propertyId)
        {
            if (propertyId != _sourcePropertyId) {
                return;
            }
 
            if (_mode == BindingMode::TwoWay ||
                _mode == BindingMode::OneWay) {
                UpdateTarget();
            }
        }
 
        void OnTargetObjectDead(INotifyObjectDead &sender)
        {
            SetTargetObject(nullptr);
        }
 
        void OnSourceObjectDead(INotifyObjectDead &sender)
        {
            SetSourceObject(nullptr);
        }
 
        void OnBindingChanged()
        {
            switch (_mode) {
                case BindingMode::OneTime:
                case BindingMode::OneWay:
                case BindingMode::TwoWay: {
                    UpdateTarget();
                    break;
                }
                case BindingMode::OneWayToSource: {
                    UpdateSource();
                    break;
                }
            }
        }
 
        template <typename TTargetValue, typename TSourceValue>
        static Binding *Create(DynamicObject *target, FieldId targetPropertyId,
                               DynamicObject *source, FieldId sourcePropertyId,
                               BindingMode mode, IValueConverter<TSourceValue, TTargetValue> *converter)
        {
            auto binding = new Binding;
 
            binding->_targetObject     = target;
            binding->_sourceObject     = source;
            binding->_targetPropertyId = targetPropertyId;
            binding->_sourcePropertyId = sourcePropertyId;
 
            binding->_mode      = mode;
            binding->_converter = converter;
 
            binding->_converterDeleter = [](void *ptr) {
                delete reinterpret_cast<IValueConverter<TSourceValue, TTargetValue> *>(ptr);
            };
            return binding;
        }
 
    public:
        template <
            typename TTargetObject,
            typename TTargetProperty,
            typename TSourceObject,
            typename TSourceProperty>
        static auto Create(DynamicObject *target, TTargetProperty TTargetObject::*targetProperty,
                           DynamicObject *source, TSourceProperty TSourceObject::*sourceProperty,
                           BindingMode mode,
                           IValueConverter<typename TSourceProperty::TValue, typename TTargetProperty::TValue> *converter = nullptr)
            -> typename std::enable_if<
                _IsProperty<TTargetProperty>::value &&
                    _IsProperty<TSourceProperty>::value &&
                    std::is_base_of<DynamicObject, TTargetObject>::value &&
                    std::is_base_of<DynamicObject, TSourceObject>::value &&
                    std::is_same<typename TTargetProperty::TValue, typename TSourceProperty::TValue>::value,
                Binding *>::type
        {
            using TTargetValue = typename TTargetProperty::TValue;
            using TSourceValue = typename TSourceProperty::TValue;
 
            auto binding = Create(
                target, Reflection::GetFieldId(targetProperty),
                source, Reflection::GetFieldId(sourceProperty), mode, converter);
 
            // update target action
            binding->_updateTargetFunc = [targetSetter = Reflection::GetPropertySetter(targetProperty),
                                          sourceGetter = Reflection::GetPropertyGetter(sourceProperty)](Binding *binding) -> bool //
            {
                IValueConverter<TSourceValue, TTargetValue> *converter =
                    reinterpret_cast<IValueConverter<TSourceValue, TTargetValue> *>(binding->_converter);
 
                if (targetSetter == nullptr ||
                    sourceGetter == nullptr ||
                    binding->_targetObject == nullptr ||
                    binding->_sourceObject == nullptr) {
                    return false;
                }
 
                if (converter) {
                    targetSetter(
                        *binding->_targetObject,
                        converter->Convert(sourceGetter(*binding->_sourceObject)));
                } else {
                    targetSetter(
                        *binding->_targetObject,
                        sourceGetter(*binding->_sourceObject));
                }
                return true;
            };
 
            // update source action
            binding->_updateSourceFunc = [targetGetter = Reflection::GetPropertyGetter(targetProperty),
                                          sourceSetter = Reflection::GetPropertySetter(sourceProperty)](Binding *binding) -> bool //
            {
                IValueConverter<TSourceValue, TTargetValue> *converter =
                    reinterpret_cast<IValueConverter<TSourceValue, TTargetValue> *>(binding->_converter);
 
                if (targetGetter == nullptr ||
                    sourceSetter == nullptr ||
                    binding->_targetObject == nullptr ||
                    binding->_sourceObject == nullptr) {
                    return false;
                }
 
                if (converter) {
                    sourceSetter(
                        *binding->_sourceObject,
                        converter->ConvertBack(targetGetter(*binding->_targetObject)));
                } else {
                    sourceSetter(
                        *binding->_sourceObject,
                        targetGetter(*binding->_targetObject));
                }
                return true;
            };
 
            binding->RegisterNotifications();
            binding->OnBindingChanged();
            return binding;
        }
 
        template <
            typename TTargetObject,
            typename TTargetProperty,
            typename TSourceObject,
            typename TSourceProperty>
        static auto Create(TTargetProperty TTargetObject::*targetProperty,
                           DynamicObject *source,
                           TSourceProperty TSourceObject::*sourceProperty,
                           BindingMode mode,
                           IValueConverter<typename TSourceProperty::TValue, typename TTargetProperty::TValue> *converter = nullptr)
            -> typename std::enable_if<
                _IsProperty<TTargetProperty>::value &&
                    _IsProperty<TSourceProperty>::value &&
                    std::is_base_of<DynamicObject, TTargetObject>::value &&
                    std::is_base_of<DynamicObject, TSourceObject>::value &&
                    std::is_same<typename TTargetProperty::TValue, typename TSourceProperty::TValue>::value,
                Binding *>::type
        {
            return Create(nullptr, targetProperty, source, sourceProperty, mode, converter);
        }
 
        template <
            typename TTargetObject,
            typename TTargetProperty,
            typename TSourceObject,
            typename TSourceProperty>
        static auto Create(TTargetProperty TTargetObject::*targetProperty,
                           TSourceProperty TSourceObject::*sourceProperty,
                           BindingMode mode,
                           IValueConverter<typename TSourceProperty::TValue, typename TTargetProperty::TValue> *converter = nullptr)
            -> typename std::enable_if<
                _IsProperty<TTargetProperty>::value &&
                    _IsProperty<TSourceProperty>::value &&
                    std::is_base_of<DynamicObject, TTargetObject>::value &&
                    std::is_base_of<DynamicObject, TSourceObject>::value &&
                    std::is_same<typename TTargetProperty::TValue, typename TSourceProperty::TValue>::value,
                Binding *>::type
        {
            return Create(nullptr, targetProperty, nullptr, sourceProperty, mode, converter);
        }
 
        template <
            typename TTargetObject,
            typename TTargetProperty,
            typename TSourceObject,
            typename TSourceProperty>
        static auto Create(DynamicObject *target, TTargetProperty TTargetObject::*targetProperty,
                           DynamicObject *source, TSourceProperty TSourceObject::*sourceProperty,
                           BindingMode mode,
                           IValueConverter<typename TSourceProperty::TValue, typename TTargetProperty::TValue> *converter)
            -> typename std::enable_if<
                _IsProperty<TTargetProperty>::value &&
                    _IsProperty<TSourceProperty>::value &&
                    std::is_base_of<DynamicObject, TTargetObject>::value &&
                    std::is_base_of<DynamicObject, TSourceObject>::value &&
                    !std::is_same<typename TTargetProperty::TValue, typename TSourceProperty::TValue>::value,
                Binding *>::type
        {
            using TTargetValue = typename TTargetProperty::TValue;
            using TSourceValue = typename TSourceProperty::TValue;
 
            auto binding = Create(
                target, Reflection::GetFieldId(targetProperty),
                source, Reflection::GetFieldId(sourceProperty), mode, converter);
 
            // update target action
            binding->_updateTargetFunc = [targetSetter = Reflection::GetPropertySetter(targetProperty),
                                          sourceGetter = Reflection::GetPropertyGetter(sourceProperty)](Binding *binding) -> bool //
            {
                IValueConverter<TSourceValue, TTargetValue> *converter =
                    reinterpret_cast<IValueConverter<TSourceValue, TTargetValue> *>(binding->_converter);
 
                if (targetSetter == nullptr ||
                    sourceGetter == nullptr ||
                    converter == nullptr ||
                    binding->_targetObject == nullptr ||
                    binding->_sourceObject == nullptr) {
                    return false;
                }
 
                targetSetter(
                    *binding->_targetObject,
                    converter->Convert(sourceGetter(*binding->_sourceObject)));
                return true;
            };
 
            // update source action
            binding->_updateSourceFunc = [targetGetter = Reflection::GetPropertyGetter(targetProperty),
                                          sourceSetter = Reflection::GetPropertySetter(sourceProperty)](Binding *binding) -> bool //
            {
                IValueConverter<TSourceValue, TTargetValue> *converter =
                    reinterpret_cast<IValueConverter<TSourceValue, TTargetValue> *>(binding->_converter);
 
                if (targetGetter == nullptr ||
                    sourceSetter == nullptr ||
                    converter == nullptr ||
                    binding->_targetObject == nullptr ||
                    binding->_sourceObject == nullptr) {
                    return false;
                }
 
                sourceSetter(
                    *binding->_sourceObject,
                    converter->ConvertBack(targetGetter(*binding->_targetObject)));
                return true;
            };
 
            binding->RegisterNotifications();
            binding->OnBindingChanged();
            return binding;
        }
 
        template <
            typename TTargetObject,
            typename TTargetProperty,
            typename TSourceObject,
            typename TSourceProperty>
        static auto Create(TTargetProperty TTargetObject::*targetProperty,
                           DynamicObject *source,
                           TSourceProperty TSourceObject::*sourceProperty,
                           BindingMode mode,
                           IValueConverter<typename TSourceProperty::TValue, typename TTargetProperty::TValue> *converter)
            -> typename std::enable_if<
                _IsProperty<TTargetProperty>::value &&
                    _IsProperty<TSourceProperty>::value &&
                    std::is_base_of<DynamicObject, TTargetObject>::value &&
                    std::is_base_of<DynamicObject, TSourceObject>::value &&
                    !std::is_same<typename TTargetProperty::TValue, typename TSourceProperty::TValue>::value,
                Binding *>::type
        {
            return Create(nullptr, targetProperty, source, sourceProperty, mode, converter);
        }
 
        template <
            typename TTargetObject,
            typename TTargetProperty,
            typename TSourceObject,
            typename TSourceProperty>
        static auto Create(TTargetProperty TTargetObject::*targetProperty,
                           TSourceProperty TSourceObject::*sourceProperty,
                           BindingMode mode,
                           IValueConverter<typename TSourceProperty::TValue, typename TTargetProperty::TValue> *converter)
            -> typename std::enable_if<
                _IsProperty<TTargetProperty>::value &&
                    _IsProperty<TSourceProperty>::value &&
                    std::is_base_of<DynamicObject, TTargetObject>::value &&
                    std::is_base_of<DynamicObject, TSourceObject>::value &&
                    !std::is_same<typename TTargetProperty::TValue, typename TSourceProperty::TValue>::value,
                Binding *>::type
        {
            return Create(nullptr, targetProperty, nullptr, sourceProperty, mode, converter);
        }
    };
}