Package org.eclipse.core.databinding.observable.value

## Class DuplexingObservableValue<T>

- java.lang.Object
- - org.eclipse.core.databinding.observable.AbstractObservable
  - - org.eclipse.core.databinding.observable.value.AbstractObservableValue<T>
    - - org.eclipse.core.databinding.observable.value.DuplexingObservableValue<T>

Type Parameters:
  `T` - the type of value being observed

All Implemented Interfaces:
  `IObservable`, `IObservableValue<T>`

    public abstract class DuplexingObservableValue<T>
    extends AbstractObservableValue<T>

Since:
  1.2

### Constructor Summary

Constructors
`DuplexingObservableValue​(IObservableList<T> target)`
`DuplexingObservableValue​(IObservableList<T> target, Object valueType)`

### Method Summary

All Methods Static Methods Instance Methods Abstract Methods Concrete Methods
`void` `addChangeListener​(IChangeListener listener)` Adds the given change listener to the list of change listeners.
`protected void` `addListener​(Object listenerType, IObservablesListener listener)`
`void` `addValueChangeListener​(IValueChangeListener<? super T> listener)`
`protected Object` `clone()`
`protected abstract T` `coalesceElements​(Collection<T> elements)`
`void` `dispose()` Disposes of this observable object, removing all listeners registered with this object, and all listeners this object might have registered on other objects.
`protected T` `doGetValue()`
`protected void` `doSetValue​(T value)` Template method for setting the value of the observable.
`protected void` `fireEvent​(ObservableEvent event)`
`protected void` `firstListenerAdded()`
`Realm` `getRealm()`
`Object` `getValueType()` The value type of this observable value, or `null` if this observable value is untyped.
`protected boolean` `hasListeners()`
`boolean` `isStale()` Returns whether the state of this observable is stale and is expected to change soon.
`protected void` `lastListenerRemoved()`
`protected void` `makeDirty()`
`protected void` `removeListener​(Object listenerType, IObservablesListener listener)`
`static <T> DuplexingObservableValue<T>` `withDefaults​(IObservableList<T> target, T emptyValue, T multiValue)` Returns a DuplexingObservableValue implementation with predefined values to use if the list is empty or contains multiple different values.

### Methods inherited from class org.eclipse.core.databinding.observable.value.AbstractObservableValue

`fireChange, fireValueChange, getValue, removeValueChangeListener, setValue`

### Methods inherited from class org.eclipse.core.databinding.observable.AbstractObservable

`addDisposeListener, addStaleListener, checkRealm, fireStale, isDisposed, removeChangeListener, removeDisposeListener, removeStaleListener`

### Methods inherited from class java.lang.Object

`equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait`

### Methods inherited from interface org.eclipse.core.databinding.observable.IObservable

`addDisposeListener, addStaleListener, getRealm, isDisposed, removeChangeListener, removeDisposeListener, removeStaleListener`

### Constructor Detail

#### DuplexingObservableValue

    public DuplexingObservableValue​(IObservableList<T> target)

Parameters:
  `target` -

#### DuplexingObservableValue

    public DuplexingObservableValue​(IObservableList<T> target,
                                    Object valueType)

Parameters:
  `target` -
  `valueType` -

### Method Detail

#### withDefaults

    public static <T> DuplexingObservableValue<T> withDefaults​(IObservableList<T> target,
                                                               T emptyValue,
                                                               T multiValue)

Returns a DuplexingObservableValue implementation with predefined values to use if the list is empty or contains multiple different values.

Type Parameters:
  `T` -
Parameters:
  `target` - the observable list
  `emptyValue` - the value to use when the target list is empty
  `multiValue` - the value to use when the target list contains multiple values that are not equivalent to each other.
Returns:
  a DuplexingObservableValue implementation with predefined values to use if the list is empty or contains multiple different values.

#### firstListenerAdded

    protected void firstListenerAdded()

#### lastListenerRemoved

    protected void lastListenerRemoved()

#### makeDirty

    protected final void makeDirty()

#### isStale

    public boolean isStale()

Description copied from interface: `IObservable`
Returns whether the state of this observable is stale and is expected to change soon. A non-stale observable that becomes stale will notify its stale listeners. A stale object that becomes non-stale does so by changing its state and notifying its change listeners, it does not notify its stale listeners about becoming non-stale. Clients that do not expect asynchronous changes may ignore staleness of observable objects.

Specified by:
  `isStale` in interface `IObservable`
Overrides:
  `isStale` in class `AbstractObservableValue<T>`
Returns:
  true if this observable's state is stale and will change soon.

#### doGetValue

    protected T doGetValue()

Specified by:
  `doGetValue` in class `AbstractObservableValue<T>`

#### coalesceElements

    protected abstract T coalesceElements​(Collection<T> elements)

#### doSetValue

    protected void doSetValue​(T value)

Description copied from class: `AbstractObservableValue`
Template method for setting the value of the observable. By default the method throws an `UnsupportedOperationException`.

Overrides:
  `doSetValue` in class `AbstractObservableValue<T>`

#### getValueType

    public Object getValueType()

Description copied from interface: `IObservableValue`
The value type of this observable value, or `null` if this observable value is untyped.

Returns:
  the value type, or `null`

#### addChangeListener

    public void addChangeListener​(IChangeListener listener)

Description copied from interface: `IObservable`
Adds the given change listener to the list of change listeners. Change listeners are notified about changes of the state of this observable in a generic way, without specifying the change that happened. To get the changed state, a change listener needs to query for the current state of this observable.

Specified by:
  `addChangeListener` in interface `IObservable`
Overrides:
  `addChangeListener` in class `AbstractObservable`

#### addValueChangeListener

    public void addValueChangeListener​(IValueChangeListener<? super T> listener)

Specified by:
  `addValueChangeListener` in interface `IObservableValue<T>`
Overrides:
  `addValueChangeListener` in class `AbstractObservableValue<T>`

#### dispose

    public void dispose()

Description copied from interface: `IObservable`
Disposes of this observable object, removing all listeners registered with this object, and all listeners this object might have registered on other objects.

Specified by:
  `dispose` in interface `IObservable`
Overrides:
  `dispose` in class `AbstractObservable`

#### addListener

    protected void addListener​(Object listenerType,
                               IObservablesListener listener)

Parameters:
  `listenerType` -
  `listener` -

#### removeListener

    protected void removeListener​(Object listenerType,
                                  IObservablesListener listener)

Parameters:
  `listenerType` -
  `listener` -

#### hasListeners

    protected boolean hasListeners()

#### fireEvent

    protected void fireEvent​(ObservableEvent event)

#### getRealm

    public Realm getRealm()

Returns:
  Returns the realm.

#### clone

    protected Object clone()
                    throws CloneNotSupportedException

Overrides:
  `clone` in class `Object`
Throws:
  `CloneNotSupportedException`