The standard base class to implement the
Presentation Model pattern,
that represents the state and behavior of a presentation independently
of the GUI components used in the interface. This
pattern
is described in Martin Fowler's upcoming
addition
to his "Patterns of Enterprise Application Architecture". More details
around this implementation of the Presentation Model pattern and a 3-tier
Swing client architecture with a presentation model layer can be found in
the
JGoodies
Binding presentation. This architecture is supported
by the JGoodies Binding library. The PresentationModel pattern is known
to users of VisualWorks Smalltalk as
ApplicationModel.
This class minimizes the effort required to bind, edit,
buffer, and observe the bound properties of an exchangeable bean.
Therefore it provides five groups of features that are described below:
- adapt bean properties,
- change the adapted bean,
- buffer values,
- observe the buffering state, and
- track changes in adapted bean properties.
Typically this class will be extended to add custom models, Actions,
presentation logic, model operations and other higher-level behavior.
However, in simple cases you can use this class as-is.
Several methods are intended to be used as-is and a typical subclass
should not modify them. For example #isChanged, #isBuffering,
#getBean, #setBean, #getBeanChannel, #getModel, #getBufferedModel,
#getTriggerChannel, #setTriggerChannel, #triggerCommit and #triggerFlush.
Adapting Bean Properties
The method
getModel(String)
vends ValueModels that adapt
a bound bean property of an exchangeable bean. These ValueModels will be
requested from an underlying BeanAdapter.
To get such a model you specify the name of the bean property.
All properties adapted must be read-write and must comply with
the Java Bean coding conventions.
In case you need to adapt a read-only or write-only property,
or if the bean uses custom names for the reader and writer,
use
getModel(String,String,String)
.
Also note that you must not mix calls to these methods for the same
property name. For details see the JavaDoc class comment in
BeanAdapter
.
Changing the Adapted Bean
The adapted bean is not stored in this PresentationModel.
Instead it is held by a ValueModel, the
bean channel
- just as in the PropertyAdapter and BeanAdapter.
This indirection enables you to manage the adapted bean outside
of this PresentationModel, and it enables you to share bean channels
between multiple PresentationModels, PropertyAdapters, and BeanAdapters.
The bean channel is used by all adapting models created
by the factory methods
#getModel
.
You can get and set the current bean by means of
#getBean
and
#setBean
. Or you can set a new value to the bean channel.
PresentationModel fires three PropertyChangeEvents if the bean changes:
beforeBean,
bean and
afterBean. This is useful
when sharing a bean channel and you must perform an operation before
or after other listeners handle a bean change. Since you cannot rely
on the order listeners will be notified, only the
beforeBean
and
afterBean events are guaranteed to be fired before and
after the bean change is fired.
Note that
#getBean()
returns the new bean before
any of these three PropertyChangeEvents is fired. Therefore listeners
that handle these events must use the event's old and new value
to determine the old and new bean.
The order of events fired during a bean change is:
- the bean channel fires a value change,
- this model fires a beforeBean change,
- this model fires the bean change,
- this model fires an afterBean change.
Buffering Values
At the core of this feature are the methods
getBufferedModel(String)
that vend BufferedValueModels that wrap an adapted bean property.
The buffer can be committed or flushed using
#triggerCommit
and
#triggerFlush
respectively.
The trigger channel is provided as a bound Java bean property
triggerChannel that must be a non-
null
ValueModel
with values of type
Boolean
.
Attempts to read or write other value types may be rejected
with runtime exceptions.
By default the trigger channel is initialized as an instance of
Trigger
. As an alternative it can be set in the constructor.
Observing the Buffering State
This class also provides support for observing the buffering state
of the BufferedValueModels created with this model. The buffering state
is useful for UI actions and operations that are enabled or disabled
if there are pending changes, for example on OK or APPLY button.
API users can request the buffering state via
#isBuffering
and can observe the bound property
buffering.
Tracking Changes in the Adapted Bean
PresentationModel provides support for observing bean property changes
and it tracks all changes to report the overall changed state.
The latter is useful to detect whether the bean has changed at all,
for example to mark the bean as dirty, so it will be updated in a database.
API users can request the changed state via
#isChanged
and can observe the bound property
changed.
If you want to track changes of other ValueModels, bean properties,
or of submodels, register them using
#observeChanged
.
To reset the changed state invoke
#resetChanged
.
In case you track the changed state of submodels you should override
#resetChanged
to reset the changed state in these submodels.
The changed state changes once only (from false to true). If you need
instant notifications about changes in the properties of the target bean,
you can register PropertyChangeListeners with this model. This is useful
if you change the bean and don't want to move your listeners from one bean
to the other. And it's useful if you want to observe multiple bean
properties at the same time. These listeners are managed by the method set
#addBeanPropertyChangeListener
and
#removeBeanPropertyChangeListener
.
Listeners registered via these methods will be removed
from the old bean before the bean changes and will be re-added after
the new bean has been set. Therefore these listeners will be notified
about changes only if the current bean changes a property. They won't be
notified if the bean changes - and in turn the property value. If you want
to observes property changes caused by bean changes too, register with
the adapting ValueModel as returned by
#getModel(String)
.
Instance Creation
PresentationModel can be instantiated using four different constructors:
you can specify the target bean directly, or you can provide a
bean channel to access the bean indirectly.
In the latter case you specify a
ValueModel
that holds the bean that in turn holds the adapted property.
In both cases the target bean is accessed indirectly through
the bean channel. In both cases you can specify a custom trigger channel,
or you can use a default trigger channel.
Note: This PresentationModel provides bound bean properties
and you can register and unregister PropertyChangeListers as usual using
#addPropertyChangeListener
and
#removePropertyChangeListener
. Do not mix up
the model listeners with the listeners registered with the bean.
Warning: PresentationModels register a
PropertyChangeListener with the target bean. Hence, a bean has a reference
to all PresentationModels that hold it as target bean. To avoid memory leaks
it is recommended to remove this listener if the bean lives much longer
than the PresentationModel, enabling the garbage collector to remove
the PresentationModel.
Setting a PresentationModel's target bean to null removes this listener,
which in turn clears the reference from the bean to the PresentationModel.
To do so, you can call
setBean(null)
or set the
bean channel's value to null.
As an alternative you can use event listener lists in your beans
that implement references with
WeakReference
.
Setting the bean to null has side effects, which is fine in most cases.
However, you can release all listeners by calling
#release
.
TODO: Further improve the class comment.
TODO: Consider adding a feature to ensure that update notifications
are performed in the event dispatch thread. In case the adapted bean
is changed in a thread other than the event dispatch thread, such
a feature would help complying with Swing's single thread rule.
The feature could be implemented by an extended PropertyChangeSupport.
TODO: I plan to improve the support for adapting beans that do not fire
PropertyChangeEvents. This affects the classes PropertyAdapter, BeanAdapter,
and PresentationModel. Basically the PropertyAdapter and the BeanAdapter's
internal SimplePropertyAdapter's shall be able to optionally self-fire
a PropertyChangeEvent in case the bean does not. There are several
downsides with self-firing events compared to bound bean properties.
See
Issue
49 for more information about the downsides.
The observeChanges constructor parameter shall be replaced by a more
fine-grained choice to not observe (former observeChanges=false),
to observe bound properties (former observeChanges=true), and a new
setting for self-firing PropertyChangeEvents if a value is set.
The latter case may be further split up to specify how the
self-fired PropertyChangeEvent is created:
- oldValue=null, newValue=null
- oldValue=null, newValue=the value set
- oldValue=value read before the set, newValue=the value set
- oldValue=value read before the set, newValue=value read after the set
addBeanPropertyChangeListener
public void addBeanPropertyChangeListener(PropertyChangeListener listener)
Adds a PropertyChangeListener to the list of bean listeners. The
listener is registered for all bound properties of the target bean.
The listener will be notified if and only if this BeanAdapter's current
bean changes a property. It'll not be notified if the bean changes.
If listener is
null
, no exception is thrown and
no action is performed.
listener
- the PropertyChangeListener to be added
addBeanPropertyChangeListener
public void addBeanPropertyChangeListener(String propertyName,
PropertyChangeListener listener)
Adds a PropertyChangeListener to the list of bean listeners for a
specific property. The specified property may be user-defined.
The listener will be notified if and only if this BeanAdapter's
current bean changes the specified property. It'll not be notified
if the bean changes. If you want to observe property changes and
bean changes, you may observe the ValueModel that adapts this property
- as returned by
#getModel(String)
.
Note that if the bean is inheriting a bound property, then no event
will be fired in response to a change in the inherited property.
If listener is
null
, no exception is thrown and
no action is performed.
propertyName
- one of the property names listed abovelistener
- the PropertyChangeListener to be added
afterBeanChange
public void afterBeanChange(B oldBean,
B newBean)
The underlying BeanAdapter has changed the target bean.
Allows to perform actions after the bean changed.
For example you can re-add listeners that were removed in
#beforeBeanChange
. Or you can reset values,
reset custom changed state, set fields to
null
etc.
The default behavior resets the change tracker's
changed state
and fires a PropertyChangeEvent for the property
#PROPERTYNAME_AFTER_BEAN
.
Note: Subclasses that override this method
must invoke super or perform the same behavior.
This method is invoked by the BeanChangeHandler listening to the
afterBean non-readable property of the BeanAdapter.
oldBean
- the bean that was adapted before the changenewBean
- the bean that is already the new target bean
beforeBeanChange
public void beforeBeanChange(B oldBean,
B newBean)
The underlying BeanAdapter is about to change the bean.
Allows to perform actions before the bean change happens.
For example you can remove listeners that shall not be notified
if adapted properties change just because of the bean change.
Or you can reset values, set fields to
null
etc.
The default behavior fires a PropertyChangeEvent for property
#PROPERTYNAME_BEFORE_BEAN
.
Note: Subclasses that override this method
must invoke super or perform the same behavior.
This method is invoked by the BeanChangeHandler listening to the
beforeBean non-readable property of the BeanAdapter.
oldBean
- the bean before the changenewBean
- the bean that will be adapted after the change
createBeanAdapter
protected BeanAdapter createBeanAdapter(ValueModel beanChannel)
Creates and returns a BeanAdapter for the given bean channel.
For compatibility with the 1.0.x, 1.1.x, and 1.2.x series,
this default implementation creates a BeanAdapter that always observes
the bean. Subclasses may override to observe only observable beans.
Here's an example code for a custom implementation:
boolean observe =
(beanChannel == null)
|| (beanChannel.getValue() == null)
|| BeanUtils.supportsBoundProperties((beanChannel.getValue().getClass());
return new BeanAdapter(beanChannel, observe);
A future implementation shall return a BeanAdapter-like interface,
not a BeanAdapter.
beanChannel
- the ValueModel that holds the bean
getBean
public B getBean()
Returns the bean that holds the adapted properties. This bean
is the bean channel's content.
- the bean that holds the adapted properties
getBeanChannel
public ValueModel getBeanChannel()
Returns the ValueModel that holds the bean that in turn holds
the adapted properties. This bean channel is shared by the
PropertyAdapters created by the factory methods
#getModel
and #getBufferedModel
.
- the ValueModel that holds the bean that in turn
holds the adapted properties
getBeanPropertyChangeListeners
public PropertyChangeListener[] getBeanPropertyChangeListeners()
Returns an array of all the property change listeners
registered on this component.
- all of this component's
PropertyChangeListener
s
or an empty array if no property change
listeners are currently registered
getBeanPropertyChangeListeners
public PropertyChangeListener[] getBeanPropertyChangeListeners(String propertyName)
Returns an array of all the listeners which have been associated
with the named property.
propertyName
- the name of the property to lookup listeners
- all of the
PropertyChangeListeners
associated with
the named property or an empty array if no listeners have
been added
getBufferedComponentModel
public ComponentValueModel getBufferedComponentModel(String propertyName)
Looks up or creates a buffered component adapter to the read-write
property with the given name on this PresentationModel's bean channel.
Creates a ComponentValueModel that wraps a BufferedValueModel that
in turn wraps a ValueModel that adapts the bean property with the
specified name. The buffered model uses this PresentationModel's
trigger channel to listen for commit and flush events.
The ComponentValueModel allows to set component state in this
presentation model.
The created ComponentValueModel is stored in a Map. Hence
subsequent calls to this method with the same property name
return the same ComponentValueModel.
To prevent potential runtime errors this method eagerly looks up
the associated PropertyDescriptor if the target bean is not null.
For each property name all calls to this method
and to
#getBufferedModel(String, String, String)
must use
the same getter and setter names. Attempts to violate this constraint
will be rejected with an IllegalArgumentException. Especially once
you've called this method you must not call
#getBufferedModel(String, String, String)
with a non-null
getter or setter name. And vice versa, once you've called the latter
method with a non-null getter or setter name, you must not call
this method.
propertyName
- the name of the read-write property to adapt
- a ComponentValueModel that wraps a buffered adapter
to the property with the given name
on this model's bean channel using this model's trigger channel
getBufferedModel
public BufferedValueModel getBufferedModel(String propertyName)
Looks up or creates a buffered adapter to the read-write property
with the given name on this PresentationModel's bean channel. Creates a
BufferedValueModel that wraps a ValueModel that adapts the bean property
with the specified name. The buffered model uses this PresentationModel's
trigger channel to listen for commit and flush events.
The created BufferedValueModel is stored in a Map. Hence
subsequent calls to this method with the same property name
return the same BufferedValueModel.
To prevent potential runtime errors this method eagerly looks up
the associated PropertyDescriptor if the target bean is not null.
For each property name all calls to this method
and to
#getBufferedModel(String, String, String)
must use
the same getter and setter names. Attempts to violate this constraint
will be rejected with an IllegalArgumentException. Especially once
you've called this method you must not call
#getBufferedModel(String, String, String)
with a non-null
getter or setter name. And vice versa, once you've called the latter
method with a non-null getter or setter name, you must not call
this method.
propertyName
- the name of the read-write property to adapt
- a buffered adapter to the property with the given name
on this model's bean channel using this model's trigger channel
getBufferedModel
public BufferedValueModel getBufferedModel(String propertyName,
String getterName,
String setterName)
Looks up or creates a buffered adapter to the read-write property
with the given name on this PresentationModel's bean channel using
the specified getter and setter name to read and write values. Creates
a
BufferedValueModel
that wraps a
ValueModel
that adapts the bean property with the specified name.
The buffered model uses this PresentationModel's trigger channel
to listen for commit and flush events.
The created BufferedValueModel is stored in a Map so it can be
looked up if it is requested multiple times.
To prevent potential runtime errors this method eagerly looks up
the associated PropertyDescriptor if the target bean is not null.
For each property name all calls to this method
and to
#getBufferedModel(String)
must use the same
getter and setter names. Attempts to violate this constraint
will be rejected with an IllegalArgumentException. Especially
once you've called this method with a non-null getter or setter name,
you must not call
#getBufferedModel(String)
. And vice versa,
once you've called the latter method you must not call this method
with a non-null getter or setter name.
propertyName
- the name of the property to adaptgetterName
- the name of the method that reads the valuesetterName
- the name of the method that sets the value
- a buffered adapter to the property with the given name
on this model's bean channel using this model's trigger channel
getBufferedValue
public Object getBufferedValue(String propertyName)
Returns the value of specified buffered bean property.
It is a shorthand for writing
getBufferedModel(propertyName).getValue()
As a side-effect, this method may create a buffered model.
propertyName
- the name of the property to be read
- the value of the adapted bean property, null if the bean is null
getComponentModel
public ComponentValueModel getComponentModel(String propertyName)
Looks up and lazily creates a ComponentValueModel that adapts
the bound property with the specified name. Uses the standard
Bean introspection to look up the getter and setter names.
Subsequent calls to this method with the same property name
return the same ComponentValueModel.
To prevent potential runtime errors it eagerly looks up
the associated PropertyDescriptor if the target bean is not null.
For each property name all calls to this method
and to
#getModel(String, String, String)
must use
the same getter and setter names. Attempts to violate this constraint
will be rejected with an IllegalArgumentException. Especially once
you've called this method you must not call
#getModel(String, String, String)
with a non-null
getter or setter name. And vice versa, once you've called the latter
method with a non-null getter or setter name, you must not call
this method.
This returned ComponentValueModel provides convenience type converter
method from AbstractValueModel and allows to modify GUI state such as
enabled, visible, and editable in this presentation model.
This can significantly shrink the source code necessary to handle
GUI state changes.
propertyName
- the name of the property to adapt
- a ValueModel that adapts the property with the specified name
getModel
public AbstractValueModel getModel(String propertyName)
Looks up and lazily creates a ValueModel that adapts
the bound property with the specified name. Uses the
Bean introspection to look up the getter and setter names.
Subsequent calls to this method with the same property name
return the same ValueModel.
To prevent potential runtime errors it eagerly looks up
the associated PropertyDescriptor if the target bean is not null.
For each property name all calls to this method
and to
#getModel(String, String, String)
must use
the same getter and setter names. Attempts to violate this constraint
will be rejected with an IllegalArgumentException. Especially once
you've called this method you must not call
#getModel(String, String, String)
with a non-null
getter or setter name. And vice versa, once you've called the latter
method with a non-null getter or setter name, you must not call
this method.
This method uses a return type of AbstractValueModel, not a ValueModel.
This makes the AbstractValueModel convenience type converters available,
which can significantly shrink the source code necessary to read and
write values from/to these models.
propertyName
- the name of the property to adapt
- a ValueModel that adapts the property with the specified name
getModel
public AbstractValueModel getModel(String propertyName,
String getterName,
String setterName)
Looks up and lazily creates a ValueModel that adapts the bound property
with the given name. Unlike
#getModel(String)
this method bypasses the Bean Introspection and uses the given getter
and setter names to setup the access to the adapted Bean property.
Subsequent calls to this method with the same parameters
will return the same ValueModel.
To prevent potential runtime errors this method eagerly looks up
the associated PropertyDescriptor if the target bean is not null.
For each property name all calls to this method
and to
#getModel(String)
must use the same
getter and setter names. Attempts to violate this constraint
will be rejected with an IllegalArgumentException. Especially
once you've called this method with a non-null getter or setter name,
you must not call
#getModel(String)
. And vice versa,
once you've called the latter method you must not call this method
with a non-null getter or setter name.
This method uses a return type of AbstractValueModel, not a ValueModel.
This makes the AbstractValueModel convenience type converters available,
which can significantly shrink the source code necessary to read and
write values from/to these models.
propertyName
- the name of the property to adaptgetterName
- the name of the method that reads the valuesetterName
- the name of the method that sets the value
- a ValueModel that adapts the property with the specified name
getTriggerChannel
public ValueModel getTriggerChannel()
Returns a ValueModel that can be shared and used to trigger commit
and flush events in BufferedValueModels. The trigger channel's value
changes to true in
#triggerCommit
and it changes to false
in
#triggerFlush
.
This trigger channel is used to commit and flush values
in the BufferedValueModels returned by
#getBufferedModel
.
- this model's trigger channel
getValue
public Object getValue(String propertyName)
Returns the value of specified bean property,
null
if the current bean is
null
.
This operation is supported only for readable bean properties.
propertyName
- the name of the property to be read
- the value of the adapted bean property, null if the bean is null
isBuffering
public boolean isBuffering()
Answers whether any of the buffered models is buffering.
Useful to enable and disable UI actions and operations
that depend on the buffering state.
- true if any of the buffered models is buffering,
false, if all buffered models write-through
isChanged
public boolean isChanged()
Answers whether one of the registered ValueModels has changed
since the changed state has been reset last time.
Note: Unlike
#resetChanged
this method
is not intended to be overridden by subclasses.
If you want to track changes of other ValueModels, bean properties, or
of submodels, register them by means of
#observeChanged
.
Overriding
#isChanged
to include the changed state
of submodels would return the correct changed value, but it would bypass
the change notification from submodels to this model.
Therefore submodels must be observed, which can be achieve using
#observeChanged
.
To reset the changed state invoke
#resetChanged
.
In case you track the changed state of submodels override
#resetChanged
to reset the changed state in these
submodels too.
- true if an observed property has changed since the last reset
observeChanged
public void observeChanged(Object bean,
String propertyName)
Observes the specified readable bound bean property in the given bean.
bean
- the bean to be observedpropertyName
- the name of the readable bound bean property
observeChanged
public void observeChanged(ValueModel valueModel)
Observes value changes in the given ValueModel.
valueModel
- the ValueModel to observe
release
public void release()
Removes the PropertyChangeHandler from the observed bean,
if the bean is not
null
.
Also removes all listeners from the bean that have been registered
with
#addBeanPropertyChangeListener
before.
PresentationModels have a PropertyChangeListener registered with
the target bean. Hence, a bean has a reference to all PresentationModels
that hold it as bean. To avoid memory leaks it is recommended to remove
this listener, if the bean lives much longer than the PresentationModel,
enabling the garbage collector to remove the PresentationModel.
To do so, you can call
setBean(null)
or set the
bean channel's value to null.
As an alternative you can use event listener lists in your beans
that implement references with
WeakReference
.
Setting the bean to null has side-effects, for example the model
fires a change event for the bound property
bean and
other properties.
And the value of ValueModel's vent by this model may change.
However, typically this is fine and setting the bean to null
is the first choice for removing the reference from the bean to
the PresentationModel.
Another way to clear the reference from the target bean is to call
this
#release
method. It has no side-effects, but
the PresentationModel must not be used anymore once #release
has been called.
setBean(Object)
, java.lang.ref.WeakReference
removeBeanPropertyChangeListener
public void removeBeanPropertyChangeListener(PropertyChangeListener listener)
Removes a PropertyChangeListener from the list of bean listeners.
This method should be used to remove PropertyChangeListeners that
were registered for all bound properties of the target bean.
If listener is
null
, no exception is thrown and
no action is performed.
listener
- the PropertyChangeListener to be removed
removeBeanPropertyChangeListener
public void removeBeanPropertyChangeListener(String propertyName,
PropertyChangeListener listener)
Removes a PropertyChangeListener from the listener list for a specific
property. This method should be used to remove PropertyChangeListeners
that were registered for a specific bound property.
If listener is
null
, no exception is thrown and
no action is performed.
propertyName
- a valid property namelistener
- the PropertyChangeListener to be removed
resetChanged
public void resetChanged()
Resets this model's changed state to
false
.
Therefore it resets the changed states of the change tracker
and the underlying bean adapter.
Subclasses may override this method to reset the changed state
of submodels. The overriding method must invoke this super behavior.
For example if you have a MainModel that is composed of
two submodels Submodel1 and Submodel2, you may write:
public void resetChanged() {
super.resetChanged();
getSubmodel1().resetChanged();
getSubmodel2().resetChanged();
}
retractInterestFor
public void retractInterestFor(Object bean,
String propertyName)
Retracts interest for the specified readable bound bean property
in the given bean.
bean
- the bean to be observedpropertyName
- the name of the readable bound bean property
retractInterestFor
public void retractInterestFor(ValueModel valueModel)
Retracts interest for value changes in the given ValueModel.
valueModel
- the ValueModel to observe
setBean
public void setBean(B newBean)
Sets a new bean as content of the bean channel.
All adapted properties will reflect this change.
setBufferedValue
public void setBufferedValue(String propertyName,
Object newValue)
Buffers the given value for the specified bean property.
It is a shorthand for writing
getBufferedModel(propertyName).setValue(newValue)
As a side-effect, this method may create a buffered model.
propertyName
- the name of the property to setnewValue
- the value to set
setChanged
protected void setChanged(boolean newValue)
setTriggerChannel
public void setTriggerChannel(ValueModel newTriggerChannel)
Sets the given ValueModel as this model's new trigger channel.
Sets the new trigger channel in all existing BufferedValueModels
that have been created using #getBufferedModel
.
Subsequent invocations of #triggerCommit
and
#triggerFlush
will trigger commit and flush events
using the new trigger channel.
newTriggerChannel
- the ValueModel to be set as
this model's new trigger channel
setValue
public void setValue(String propertyName,
Object newValue)
Sets the given new value for the specified bean property. Does nothing
if this adapter's bean is
null
. If the setter associated
with the propertyName throws a PropertyVetoException, it is silently
ignored.
Notifies the associated value change listeners if the bean reports
a property change. Note that a bean may suppress PropertyChangeEvents
if the old and new value are the same, or if the old and new value
are equal.
This operation is supported only for writable bean properties.
propertyName
- the name of the property to setnewValue
- the value to set
setVetoableValue
public void setVetoableValue(String propertyName,
Object newValue)
throws PropertyVetoException
Sets a new value for the specified bean property. Does nothing if the
bean is
null
. If the setter associated with the propertyName
throws a PropertyVetoException, this methods throws the same exception.
Notifies the associated value change listeners if the bean reports
a property change. Note that a bean may suppress PropertyChangeEvents
if the old and new value are the same, or if the old and new value
are equal.
This operation is supported only for writable bean properties.
propertyName
- the name of the property to setnewValue
- the value to set
triggerCommit
public void triggerCommit()
Sets the trigger channel to true which in turn triggers commit
events in all BufferedValueModels that share this trigger.
triggerFlush
public void triggerFlush()
Sets the trigger channel to false which in turn triggers flush
events in all BufferedValueModels that share this trigger.