Jump to content

Binding properties pattern: Difference between revisions

Edit links
From Wikipedia, the free encyclopedia
Browse history interactively
← Previous edit
Content deleted Content added
VisualWikitext
m →‎Sample code: 4-space indention
 
(14 intermediate revisions by 9 users not shown)
Line 1: Line 1:
{{Confusing|date=May 2017}}
{{Confusing|date=May 2017}}


The '''Binding properties pattern''' is combining multiple [[Observer pattern|observers]] to force properties in different objects to be synchronized or coordinated in some way. This [[Software design pattern|pattern]] was first described as a technique by Victor Porton.<ref name=":c3_bp">{{Cite web|url =http://c2.com/cgi/wiki?BindingProperties|title = Binding Properties|date = |accessdate = 4 February 2015|website = Cunningham & Cunningham|publisher = Cunningham & Cunningham|last = |first = }}</ref><ref name=":ec_btpoo">{{Cite web|url = http://ex-code.com/articles/binding-properties.html|title = Binding together Properties of Objects: Extreme Code Software|date = |accessdate = 1 September 2008|website = Ex-code|publisher = Ex-code|last = Porton|first = V.}}</ref> This pattern comes under [[concurrency patterns]].
The '''binding properties pattern''' is combining multiple [[Observer pattern|observers]] to force properties in different objects to be synchronized or coordinated in some way. This [[Software design pattern|pattern]] was first described as a technique by Victor Porton.<ref name=":c3_bp">{{Cite web|url =http://c2.com/cgi/wiki?BindingProperties|title = Binding Properties|access-date = 4 February 2015|website = Cunningham & Cunningham|publisher = Cunningham & Cunningham}}</ref><ref name=":ec_btpoo">{{Cite web|url = https://cloudflare-ipfs.com/ipfs/QmNj5xHJx9JEWfPAttTTitXnjFKwm319nLZU8BfAoMwx9h/|title = Binding together Properties of Objects|access-date = 25 February 2021|publisher = Victor Porton|last = Porton|first = V.}}</ref> This pattern comes under [[concurrency patterns]].


==Comparison with aspect-oriented implementation==
==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.<ref name=":accm_aautbom">{{Citation |title = The Association Construct in Conceptual Modelling - An Analysis Using the Bunge Ontological Model|last = Evermann|first = J.|publisher = School of Information Management, Victoria University|year = |location = Wellington, New Zealand|volume = |pages = }}</ref>
As an alternative to the aspect-oriented implementation of mutual properties, property binding can be proposed. In LibPropC++ C++ library it is implemented too.<ref name=":accm_aautbom">{{Citation |title = The Association Construct in Conceptual Modelling - An Analysis Using the Bunge Ontological Model|last = Evermann|first = J.|publisher = School of Information Management, Victoria University|location = Wellington, New Zealand}}</ref>


Some weakness in the LibPropC++ (with property binding):
Some weakness in the LibPropC++ (with property binding):
Line 16: Line 16:
Infinite loops can be eliminated by blocking the signal, or comparing the assigned value with the property value before assignment, or eliminating unnecessary assignments.<ref name=":ec_btpoo"/><ref name=":accm_aautbom"/>
Infinite loops can be eliminated by blocking the signal, or comparing the assigned value with the property value before assignment, or eliminating unnecessary assignments.<ref name=":ec_btpoo"/><ref name=":accm_aautbom"/>


Binding properties of different types can be achieved through [[Type Conversion]]s.<ref name=":ec_btpoo"/><ref name=":accm_aautbom"/>
Binding properties of different types can be achieved through [[type conversion]]s.<ref name=":ec_btpoo"/><ref name=":accm_aautbom"/>


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.<ref name=":ec_btpoo"/><ref name=":accm_aautbom"/>
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.<ref name=":ec_btpoo"/><ref name=":accm_aautbom"/>


{{Rounded|w=30%|bg=magenta|content={{Coloredlink|white|Procedural programming}}<br/>
{{box|radius=5px|width=auto|background=magenta|1={{Coloredlink|white|Procedural programming}}<br/>
{{Rounded|bg=yellow|content=[[Object-oriented programming]]<br/>
{{box|radius=5px|background=yellow|1=[[Object-oriented programming]]<br/>
{{Rounded|bg=blue|content={{white|Singals/event programming}}<br/>
{{box|radius=5px|background=blue|1={{white|Signals/event programming}}<br/>
{{Rounded|bg=green|content={{white|Components with properties}}<br/>
{{box|radius=5px|background=green|1={{white|Components with properties}}<br/>
{{Rounded|bg=lime|content=binding properties together}}}}}}}}}}<ref name=":ec_btpoo"/>
{{box|radius=5px|background=lime|1=binding properties together}}}}}}}}}}<ref name=":ec_btpoo"/>


==Resulting Context==
==Resulting context==
Properties are being kept synchronized automatically. Between library calls they always have the values expressed by the EqualityConstraints.<ref name=":accm_aautbom"/>
Properties are being kept synchronized automatically. Between library calls they always have the values expressed by the EqualityConstraints.<ref name=":accm_aautbom"/>


Line 32: Line 32:
Property changes watching mechanism acquires some resources.<ref name=":accm_aautbom"/>
Property changes watching mechanism acquires some resources.<ref name=":accm_aautbom"/>


==Sample Code==
==Sample code==
Code sketch for one-way binding may look like as follows:
Code sketch for one-way binding may look like as follows:
<source lang="cpp">
<syntaxhighlight lang="cpp">


bind_multiple_one_way(src_obj, src_prop, dst_objs[], dst_props[])
bind_multiple_one_way(src_obj, src_prop, dst_objs[], dst_props[])
{
{
for (i, j) in (dst_objs, dst_props)
for (i, j) in (dst_objs, dst_props)
{
{
bind_properties_one_way(src_obj, src_prop, i, j);
bind_properties_one_way(src_obj, src_prop, i, j);
}
}
}
}
</source><ref name=":ec_btpoo"/>
</syntaxhighlight><ref name=":ec_btpoo"/>


Two-way binding can be expressed as follows (in C++):
Two-way binding can be expressed as follows (in [[C++]]):
<source lang="cpp">
<syntaxhighlight lang="cpp">
// In this pseudo-code are not taken into the account initial values assignments
// In this pseudo-code are not taken into the account initial values assignments
bind_two_way(prop1, prop2)
bind_two_way(prop1, prop2)
{
{
bind(prop1, prop2);
bind(prop1, prop2);
bind(prop2, prop1);
bind(prop2, prop1);
}
}
</source><ref name=":accm_aautbom"/>
</syntaxhighlight><ref name=":accm_aautbom"/>


Accomplishing the binding (i.e. connecting the property change notification in an event handler) may be like as follows:
Accomplishing the binding (i.e. connecting the property change notification in an event handler) may be like as follows:
<source lang="cpp">
<syntaxhighlight lang="cpp">
on_property_change(src_prop, dst_prop)
on_property_change(src_prop, dst_prop)
{
{
block_signal(src_obj, on_property_change);
block_signal(src_obj, on_property_change);
dst_prop := src_prop;
dst_prop := src_prop;
unblock_signal(src_obj, on_property_change);
unblock_signal(src_obj, on_property_change);
}
}
</source><ref name=":accm_aautbom"/>
</syntaxhighlight><ref name=":accm_aautbom"/>


==See also==
==See also==

Latest revision as of 09:30, 8 March 2024

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

[edit]

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):

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

Implementation

[edit]

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

[edit]

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

Deficiencies

[edit]

Property changes watching mechanism acquires some resources.[3]

Sample code

[edit]

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);
}

[3]

See also

[edit]

References

[edit]
  1. ^ "Binding Properties". Cunningham & Cunningham. Cunningham & Cunningham. Retrieved 4 February 2015.
  2. ^ a b c d e f g Porton, V. "Binding together Properties of Objects". Victor Porton. Retrieved 25 February 2021.
  3. ^ a b c d e f g h i j Evermann, J., The Association Construct in Conceptual Modelling - An Analysis Using the Bunge Ontological Model, Wellington, New Zealand: School of Information Management, Victoria University
Retrieved from "https://en.wikipedia.org/w/index.php?title=Binding_properties_pattern&oldid=1212531743"