PROFILPELAJAR.COM

The binding properties pattern is combining multiple observers to force properties in different objects to be synchronized or coordinated in some way. This pattern was first described as a technique by Victor Porton.^[1]^[2] This pattern comes under concurrency patterns.

Comparison with aspect-oriented implementation

As an alternative to the aspect-oriented implementation of mutual properties, property binding can be proposed. In LibPropC++ C++ library it is implemented too.^[3]

Some weakness in the LibPropC++ (with property binding):

Its use is not transparent as it requires to be declared necessary object attributes as properties and appropriate accessor methods must be provided
Binding of attributes in LibPropC++ is not designed to replace method calls
The library does not maintain an interaction history.^[3]

Implementation

There are two types of binding. One-way binding should be applied when one of the properties is read-only. In other cases, two-way binding must be applied.^[2]^[3]

Infinite loops can be eliminated by blocking the signal, or comparing the assigned value with the property value before assignment, or eliminating unnecessary assignments.^[2]^[3]

Binding properties of different types can be achieved through type conversions.^[2]^[3]

Binding properties with transformations can be achieved through reducing the transformation function to the problem of binding properties, and the function can be imaginary consider as Type Conversions.^[2]^[3]

Procedural programming

Object-oriented programming

Signals/event programming

Components with properties

binding properties together

^[2]

Resulting context

Properties are being kept synchronized automatically. Between library calls they always have the values expressed by the EqualityConstraints.^[3]

Deficiencies

Property changes watching mechanism acquires some resources.^[3]

Sample code

Code sketch for one-way binding may look like as follows:

bind_multiple_one_way(src_obj, src_prop, dst_objs[], dst_props[])
{
    for (i, j) in (dst_objs, dst_props)
    {
        bind_properties_one_way(src_obj, src_prop, i, j);
    }
}

^[2]

Two-way binding can be expressed as follows (in C++):

// In this pseudo-code are not taken into the account initial values assignments
bind_two_way(prop1, prop2)
{
    bind(prop1, prop2);
    bind(prop2, prop1);
}

^[3]

Accomplishing the binding (i.e. connecting the property change notification in an event handler) may be like as follows:

on_property_change(src_prop, dst_prop)
{
    block_signal(src_obj, on_property_change);
    dst_prop := src_prop;
    unblock_signal(src_obj, on_property_change);
}