Java tutorial
/******************************************************************************* * Copyright (c) 2005, 2015 IBM Corporation and others. * All rights reserved. This program and the accompanying materials * are made available under the terms of the Eclipse Public License v1.0 * which accompanies this distribution, and is available at * http://www.eclipse.org/legal/epl-v10.html * * Contributors: * IBM Corporation - initial API and implementation * Brad Reynolds - bugs 164268, 171616, 147515 * Matthew Hall - bug 221704, 234686, 246625, 226289, 246782, 194734, * 195222, 247997 * Thomas Kratz - bug 213787 * Lars Vogel <Lars.Vogel@vogella.com> - Bug 443399 *******************************************************************************/ package org.eclipse.core.databinding.beans; import java.beans.PropertyDescriptor; import org.eclipse.core.databinding.observable.IObservable; import org.eclipse.core.databinding.observable.Realm; import org.eclipse.core.databinding.observable.list.IObservableList; import org.eclipse.core.databinding.observable.map.IObservableMap; import org.eclipse.core.databinding.observable.masterdetail.IObservableFactory; import org.eclipse.core.databinding.observable.masterdetail.MasterDetailObservables; import org.eclipse.core.databinding.observable.set.IObservableSet; import org.eclipse.core.databinding.observable.value.IObservableValue; import org.eclipse.core.databinding.util.Policy; import org.eclipse.core.internal.databinding.beans.BeanObservableListDecorator; import org.eclipse.core.internal.databinding.beans.BeanObservableMapDecorator; import org.eclipse.core.internal.databinding.beans.BeanObservableSetDecorator; import org.eclipse.core.internal.databinding.beans.BeanObservableValueDecorator; import org.eclipse.core.internal.databinding.beans.BeanPropertyHelper; import org.eclipse.core.internal.databinding.beans.Util; import org.eclipse.core.runtime.Assert; import org.eclipse.core.runtime.IStatus; import org.eclipse.core.runtime.Status; /** * A factory for creating observable objects of Java objects that conform to the * <a href="http://java.sun.com/products/javabeans/docs/spec.html">JavaBean * specification</a> for bound properties. * * @since 1.1 * * @deprecated use <code>BeanProperties</code> instead */ final public class BeansObservables { /** * */ public static final boolean DEBUG = true; /** * Returns an observable value in the default realm tracking the current * value of the named property of the given bean. * * @param bean * the object * @param propertyName * the name of the property. May be nested e.g. "parent.name" * @return an observable value tracking the current value of the named * property of the given bean * * @deprecated use <code>BeanProperties</code> instead */ public static IObservableValue observeValue(Object bean, String propertyName) { return observeValue(Realm.getDefault(), bean, propertyName); } /** * Returns an observable value in the given realm tracking the current value * of the named property of the given bean. * * @param realm * the realm * @param bean * the object * @param propertyName * the name of the property. May be nested e.g. "parent.name" * @return an observable value tracking the current value of the named * property of the given bean * * @deprecated use <code>BeanProperties</code> instead */ public static IObservableValue observeValue(Realm realm, Object bean, String propertyName) { return BeanProperties.value(bean.getClass(), propertyName).observe(realm, bean); } /** * Returns an observable map in the given observable set's realm tracking * the current values of the named property for the beans in the given set. * Elements in the set which do not have the named property will have null * values, and attempts to {@link IObservableMap#put(Object, Object) put} * values to these elements will be ignored. * * @param domain * the set of bean objects * @param propertyName * the name of the property. May be nested e.g. "parent.name" * @return an observable map tracking the current values of the named * property for the beans in the given domain set * @since 1.2 * * @deprecated use <code>BeanProperties</code> instead */ public static IObservableMap observeMap(IObservableSet domain, String propertyName) { return BeanProperties.value(propertyName).observeDetail(domain); } /** * Returns an observable map in the given observable set's realm tracking * the current values of the named property for the beans in the given set. * * @param domain * the set of bean objects * @param beanClass * the common base type of bean objects that may be in the set * @param propertyName * the name of the property. May be nested e.g. "parent.name" * @return an observable map tracking the current values of the named * property for the beans in the given domain set * * @deprecated use <code>BeanProperties</code> instead */ public static IObservableMap observeMap(IObservableSet domain, Class beanClass, String propertyName) { return BeanProperties.value(beanClass, propertyName).observeDetail(domain); } /** * Returns an observable map in the given realm tracking the map-typed named * property of the given bean object. * * @param realm * the realm * @param bean * the bean object * @param propertyName * the name of the property. May be nested e.g. "parent.name" * @return an observable map tracking the map-typed named property of the * given bean object * @since 1.1 * * @deprecated use <code>BeanProperties</code> instead */ public static IObservableMap observeMap(Realm realm, Object bean, String propertyName) { return observeMap(realm, bean, propertyName, null, null); } /** * Returns an observable map in the given realm tracking the map-typed named * property of the given bean object. * * @param realm * the realm * @param bean * the bean object * @param propertyName * the name of the property. May be nested e.g. "parent.name" * @param keyType * the element type of the observable map's key set, or * <code>null</code> if untyped * @param valueType * the element type of the observable map's values collection, or * <code>null</code> if untyped * @return an observable map tracking the map-typed named property of the * given bean object * @since 1.2 * * @deprecated use <code>BeanProperties</code> instead */ public static IObservableMap observeMap(Realm realm, Object bean, String propertyName, Class keyType, Class valueType) { return BeanProperties.map(bean.getClass(), propertyName, keyType, valueType).observe(realm, bean); } /** * Returns an observable map in the default realm tracking the map-typed * named property of the given bean object. * * @param bean * the bean object * @param propertyName * the name of the property. May be nested e.g. "parent.name" * @return an observable map tracking the map-typed named property of the * given bean object * @since 1.2 * * @deprecated use <code>BeanProperties</code> instead */ public static IObservableMap observeMap(Object bean, String propertyName) { return observeMap(Realm.getDefault(), bean, propertyName, null, null); } /** * Returns an observable map in the default realm tracking the map-typed * named property of the given bean object. * * @param bean * the bean object * @param propertyName * the name of the property * @param keyType * the element type of the observable map's key set, or * <code>null</code> if untyped * @param valueType * the element type of the observable map's values collection, or * <code>null</code> if untyped * @return an observable map tracking the map-typed named property of the * given bean object * @since 1.2 * * @deprecated use <code>BeanProperties</code> instead */ public static IObservableMap observeMap(Object bean, String propertyName, Class keyType, Class valueType) { return observeMap(Realm.getDefault(), bean, propertyName, keyType, valueType); } /** * Returns an array of observable maps in the given observable set's realm * tracking the current values of the named properties for the beans in the * given set. Elements in the set which do not have the named property will * have null values, and attempts to * {@link IObservableMap#put(Object, Object) put} values to these elements * will be ignored. * * @param domain * the set of objects * @param propertyNames * the array of property names. May be nested e.g. "parent.name" * @return an array of observable maps tracking the current values of the * named propertys for the beans in the given domain set * @since 1.2 * * @deprecated use <code>BeanProperties</code> instead */ public static IObservableMap[] observeMaps(IObservableSet domain, String[] propertyNames) { IObservableMap[] result = new IObservableMap[propertyNames.length]; for (int i = 0; i < propertyNames.length; i++) { result[i] = observeMap(domain, propertyNames[i]); } return result; } /** * Returns an array of observable maps in the given observable set's realm * tracking the current values of the named properties for the beans in the * given set. * * @param domain * the set of objects * @param beanClass * the common base type of objects that may be in the set * @param propertyNames * the array of property names. May be nested e.g. "parent.name" * @return an array of observable maps tracking the current values of the * named propertys for the beans in the given domain set * * @deprecated use <code>BeanProperties</code> instead */ public static IObservableMap[] observeMaps(IObservableSet domain, Class beanClass, String[] propertyNames) { IObservableMap[] result = new IObservableMap[propertyNames.length]; for (int i = 0; i < propertyNames.length; i++) { result[i] = observeMap(domain, beanClass, propertyNames[i]); } return result; } /** * Returns an observable list in the given realm tracking the * collection-typed named property of the given bean object. The returned * list is mutable. * * @param realm * the realm * @param bean * the object * @param propertyName * the name of the collection-typed property * @return an observable list tracking the collection-typed named property * of the given bean object * @see #observeList(Realm, Object, String, Class) * * @deprecated use <code>BeanProperties</code> instead */ public static IObservableList observeList(Realm realm, Object bean, String propertyName) { return observeList(realm, bean, propertyName, null); } /** * Returns an observable list in the default realm tracking the * collection-typed named property of the given bean object. The returned * list is mutable. * * @param bean * the object * @param propertyName * the name of the collection-typed property * @return an observable list tracking the collection-typed named property * of the given bean object * @see #observeList(Realm, Object, String, Class) * @since 1.2 */ public static IObservableList observeList(Object bean, String propertyName) { return observeList(Realm.getDefault(), bean, propertyName); } /** * Returns an observable list in the given realm tracking the * collection-typed named property of the given bean object. The returned * list is mutable. When an item is added or removed the setter is invoked * for the list on the parent bean to provide notification to other * listeners via <code>PropertyChangeEvents</code>. This is done to provide * the same behavior as is expected from arrays as specified in the bean * spec in section 7.2. * * @param realm * the realm * @param bean * the bean object * @param propertyName * the name of the property * @param elementType * type of the elements in the list. If <code>null</code> and the * property is an array the type will be inferred. If * <code>null</code> and the property type cannot be inferred * element type will be <code>null</code>. * @return an observable list tracking the collection-typed named property * of the given bean object * * @deprecated use <code>BeanProperties</code> instead */ public static IObservableList observeList(Realm realm, Object bean, String propertyName, Class elementType) { return BeanProperties.list(bean.getClass(), propertyName, elementType).observe(realm, bean); } /** * Returns an observable list in the default realm tracking the * collection-typed named property of the given bean object. The returned * list is mutable. When an item is added or removed the setter is invoked * for the list on the parent bean to provide notification to other * listeners via <code>PropertyChangeEvents</code>. This is done to provide * the same behavior as is expected from arrays as specified in the bean * spec in section 7.2. * * @param bean * the bean object * @param propertyName * the name of the property * @param elementType * type of the elements in the list. If <code>null</code> and the * property is an array the type will be inferred. If * <code>null</code> and the property type cannot be inferred * element type will be <code>null</code>. * @return an observable list tracking the collection-typed named property * of the given bean object * @since 1.2 */ public static IObservableList observeList(Object bean, String propertyName, Class elementType) { return observeList(Realm.getDefault(), bean, propertyName, elementType); } /** * Returns an observable set in the given realm tracking the * collection-typed named property of the given bean object * * @param realm * the realm * @param bean * the bean object * @param propertyName * the name of the property * @return an observable set tracking the collection-typed named property of * the given bean object * * @deprecated use <code>BeanProperties</code> instead */ public static IObservableSet observeSet(Realm realm, Object bean, String propertyName) { return observeSet(realm, bean, propertyName, null); } /** * Returns an observable set in the default realm tracking the * collection-typed named property of the given bean object * * @param bean * the bean object * @param propertyName * the name of the property * @return an observable set tracking the collection-typed named property of * the given bean object * @since 1.2 * * @deprecated use <code>BeanProperties</code> instead */ public static IObservableSet observeSet(Object bean, String propertyName) { return observeSet(Realm.getDefault(), bean, propertyName); } /** * Returns a factory for creating observable values in the given realm, * tracking the given property of a particular bean object * * @param realm * the realm to use * @param propertyName * the name of the property. May be nested e.g. "parent.name" * @return an observable value factory * * @deprecated use <code>BeanProperties</code> instead */ public static IObservableFactory valueFactory(final Realm realm, final String propertyName) { return BeanProperties.value(propertyName).valueFactory(realm); } /** * Returns a factory for creating observable values in the current default * realm, tracking the given property of a particular bean object * * @param propertyName * the name of the property. May be nested e.g. "parent.name" * @return an observable value factory * @since 1.2 * * @deprecated use <code>BeanProperties</code> instead */ public static IObservableFactory valueFactory(String propertyName) { return valueFactory(Realm.getDefault(), propertyName); } /** * Returns a factory for creating observable lists in the given realm, * tracking the given property of a particular bean object * * @param realm * the realm to use * @param propertyName * the name of the property * @param elementType * @return an observable list factory * * @deprecated use <code>BeanProperties</code> instead */ public static IObservableFactory listFactory(final Realm realm, final String propertyName, final Class elementType) { return BeanProperties.list(propertyName, elementType).listFactory(realm); } /** * Returns a factory for creating observable lists in the current default * realm, tracking the given property of a particular bean object * * @param propertyName * the name of the property * @param elementType * @return an observable list factory * @since 1.2 * * @deprecated use <code>BeanProperties</code> instead */ public static IObservableFactory listFactory(String propertyName, Class elementType) { return listFactory(Realm.getDefault(), propertyName, elementType); } /** * Returns a factory for creating observable sets in the given realm, * tracking the given property of a particular bean object * * @param realm * the realm to use * @param propertyName * the name of the property * @return an observable set factory * * @deprecated use <code>BeanProperties</code> instead */ public static IObservableFactory setFactory(final Realm realm, final String propertyName) { return BeanProperties.set(propertyName).setFactory(realm); } /** * Returns a factory for creating observable sets in the current default * realm, tracking the given property of a particular bean object * * @param propertyName * the name of the property * @return an observable set factory * @since 1.2 * * @deprecated use <code>BeanProperties</code> instead */ public static IObservableFactory setFactory(String propertyName) { return setFactory(Realm.getDefault(), propertyName); } /** * Helper method for * <code>MasterDetailObservables.detailValue(master, valueFactory(realm, propertyName), propertyType)</code> * * @param realm * @param master * @param propertyName * the name of the property. May be nested e.g. "parent.name" * @param propertyType * can be <code>null</code> * @return an observable value that tracks the current value of the named * property for the current value of the master observable value * * @see MasterDetailObservables * * @deprecated Use * {@link #observeDetailValue(IObservableValue, String, Class)} * instead */ @Deprecated public static IObservableValue observeDetailValue(Realm realm, IObservableValue master, String propertyName, Class propertyType) { warnIfDifferentRealms(realm, master.getRealm()); IObservableValue value = MasterDetailObservables.detailValue(master, BeanProperties.value(propertyName, propertyType).valueFactory(realm), propertyType); return new BeanObservableValueDecorator(value, BeanPropertyHelper.getValueTypePropertyDescriptor(master, propertyName)); } /* package */static void warnIfDifferentRealms(Realm detailRealm, Realm masterRealm) { if (!Util.equals(detailRealm, masterRealm)) { Throwable throwable = new Throwable(); throwable.fillInStackTrace(); String message = "Detail realm (" + detailRealm //$NON-NLS-1$ + ") not equal to master realm (" //$NON-NLS-1$ + masterRealm + ")"; //$NON-NLS-1$ Policy.getLog().log(new Status(IStatus.WARNING, Policy.JFACE_DATABINDING, message, throwable)); } } /** * Helper method for * <code>MasterDetailObservables.detailValue(master, valueFactory(master.getRealm(), propertyName), propertyType)</code> * * @param master * @param propertyName * the name of the property. May be nested e.g. "parent.name" * @param propertyType * can be <code>null</code> * @return an observable value that tracks the current value of the named * property for the current value of the master observable value * * @see MasterDetailObservables * @since 1.2 * * @deprecated use <code>BeanProperties</code> instead */ public static IObservableValue observeDetailValue(IObservableValue master, String propertyName, Class propertyType) { Class beanClass = null; if (master.getValueType() instanceof Class) beanClass = (Class) master.getValueType(); return observeDetailValue(master, beanClass, propertyName, propertyType); } /** * Helper method for * <code>MasterDetailObservables.detailValue(master, valueFactory(realm, * propertyName), propertyType)</code>. This method returns an * {@link IBeanObservable} with a {@link PropertyDescriptor} based on the * given master type and property name. * * @param realm * the realm * @param master * the master observable value, for example tracking the * selection in a list * @param masterType * the type of the master observable value * @param propertyName * the property name. May be nested e.g. "parent.name" * @param propertyType * can be <code>null</code> * @return an observable value that tracks the current value of the named * property for the current value of the master observable value * * @see MasterDetailObservables * @since 1.1 * @deprecated Use * {@link #observeDetailValue(IObservableValue, Class, String, Class)} * instead. */ @Deprecated public static IObservableValue observeDetailValue(Realm realm, IObservableValue master, Class masterType, String propertyName, Class propertyType) { warnIfDifferentRealms(realm, master.getRealm()); Assert.isNotNull(masterType, "masterType cannot be null"); //$NON-NLS-1$ IObservableValue value = MasterDetailObservables.detailValue(master, BeanProperties.value(masterType, propertyName, propertyType).valueFactory(realm), propertyType); return new BeanObservableValueDecorator(value, BeanPropertyHelper.getPropertyDescriptor(masterType, propertyName)); } /** * Helper method for * <code>MasterDetailObservables.detailValue(master, valueFactory(master.getRealm(), propertyName), propertyType)</code> * . This method returns an {@link IBeanObservable} with a * {@link PropertyDescriptor} based on the given master type and property * name. * * @param master * the master observable value, for example tracking the * selection in a list * @param masterType * the type of the master observable value * @param propertyName * the property name. May be nested e.g. "parent.name" * @param propertyType * can be <code>null</code> * @return an observable value that tracks the current value of the named * property for the current value of the master observable value * * @see MasterDetailObservables * @since 1.2 * * @deprecated use <code>BeanProperties</code> instead */ public static IObservableValue observeDetailValue(IObservableValue master, Class masterType, String propertyName, Class propertyType) { return BeanProperties.value(masterType, propertyName, propertyType).observeDetail(master); } /** * Helper method for * <code>MasterDetailObservables.detailList(master, listFactory(realm, propertyName, propertyType), propertyType)</code> * * @param realm * @param master * @param propertyName * @param propertyType * can be <code>null</code> * @return an observable list that tracks the named property for the current * value of the master observable value * * @see MasterDetailObservables * @deprecated Use * {@link #observeDetailList(IObservableValue, String, Class)} * instead */ @Deprecated public static IObservableList observeDetailList(Realm realm, IObservableValue master, String propertyName, Class propertyType) { warnIfDifferentRealms(realm, master.getRealm()); IObservableList observableList = MasterDetailObservables.detailList(master, BeanProperties.list(propertyName, propertyType).listFactory(realm), propertyType); return new BeanObservableListDecorator(observableList, BeanPropertyHelper.getValueTypePropertyDescriptor(master, propertyName)); } /** * Helper method for * <code>MasterDetailObservables.detailList(master, listFactory(master.getRealm(), propertyName, propertyType), propertyType)</code> * * @param master * @param propertyName * @param propertyType * can be <code>null</code> * @return an observable list that tracks the named property for the current * value of the master observable value * * @see MasterDetailObservables * @since 1.2 * * @deprecated use <code>BeanProperties</code> instead */ public static IObservableList observeDetailList(IObservableValue master, String propertyName, Class propertyType) { Class beanClass = null; if (master.getValueType() instanceof Class) beanClass = (Class) master.getValueType(); return BeanProperties.list(beanClass, propertyName, propertyType).observeDetail(master); } /** * Helper method for * <code>MasterDetailObservables.detailSet(master, setFactory(realm, propertyName), propertyType)</code> * * @param realm * @param master * @param propertyName * @param propertyType * can be <code>null</code> * @return an observable set that tracks the named property for the current * value of the master observable value * * @see MasterDetailObservables * @deprecated Use * {@link #observeDetailSet(IObservableValue, String, Class)} * instead. */ @Deprecated public static IObservableSet observeDetailSet(Realm realm, IObservableValue master, String propertyName, Class propertyType) { warnIfDifferentRealms(realm, master.getRealm()); IObservableSet observableSet = MasterDetailObservables.detailSet(master, BeanProperties.set(propertyName, propertyType).setFactory(realm), propertyType); return new BeanObservableSetDecorator(observableSet, BeanPropertyHelper.getValueTypePropertyDescriptor(master, propertyName)); } /** * Helper method for * <code>MasterDetailObservables.detailSet(master, setFactory(master.getRealm(), propertyName), propertyType)</code> * * @param master * @param propertyName * @param propertyType * can be <code>null</code> * @return an observable set that tracks the named property for the current * value of the master observable value * * @see MasterDetailObservables * @since 1.2 * * @deprecated use <code>BeanProperties</code> instead */ public static IObservableSet observeDetailSet(IObservableValue master, String propertyName, Class propertyType) { Class beanClass = null; if (master.getValueType() instanceof Class) beanClass = (Class) master.getValueType(); return BeanProperties.set(beanClass, propertyName, propertyType).observeDetail(master); } /** * Helper method for * <code>MasterDetailObservables.detailMap(master, mapFactory(realm, propertyName))</code> * * @param realm * the realm * @param master * @param propertyName * @return an observable map that tracks the map-type named property for the * current value of the master observable value. * @since 1.1 * @deprecated Use {@link #observeDetailMap(IObservableValue, String)} * instead */ @Deprecated public static IObservableMap observeDetailMap(Realm realm, IObservableValue master, String propertyName) { warnIfDifferentRealms(realm, master.getRealm()); IObservableMap observableMap = MasterDetailObservables.detailMap(master, BeanProperties.map(propertyName).mapFactory(realm)); return new BeanObservableMapDecorator(observableMap, BeanPropertyHelper.getValueTypePropertyDescriptor(master, propertyName)); } /** * Helper method for * <code>MasterDetailObservables.detailMap(master, mapFactory(master.getRealm(), propertyName))</code> * * @param master * @param propertyName * @return an observable map that tracks the map-type named property for the * current value of the master observable value. * @since 1.2 * * @deprecated use <code>BeanProperties</code> instead */ public static IObservableMap observeDetailMap(IObservableValue master, String propertyName) { Class beanClass = null; if (master.getValueType() instanceof Class) beanClass = (Class) master.getValueType(); return BeanProperties.map(beanClass, propertyName).observeDetail(master); } /** * Returns an observable set in the given realm tracking the * collection-typed named property of the given bean object. The returned * set is mutable. When an item is added or removed the setter is invoked * for the set on the parent bean to provide notification to other listeners * via <code>PropertyChangeEvents</code>. This is done to provide the same * behavior as is expected from arrays as specified in the bean spec in * section 7.2. * * @param realm * the realm * @param bean * the bean object * @param propertyName * the name of the property * @param elementType * type of the elements in the set. If <code>null</code> and the * property is an array the type will be inferred. If * <code>null</code> and the property type cannot be inferred * element type will be <code>null</code>. * @return an observable set tracking the collection-typed named property of * the given bean object * * @deprecated use <code>BeanProperties</code> instead */ public static IObservableSet observeSet(Realm realm, Object bean, String propertyName, Class elementType) { return BeanProperties.set(bean.getClass(), propertyName, elementType).observe(realm, bean); } /** * Returns an observable set in the current default realm tracking the * collection-typed named property of the given bean object. The returned * set is mutable. When an item is added or removed the setter is invoked * for the set on the parent bean to provide notification to other listeners * via <code>PropertyChangeEvents</code>. This is done to provide the same * behavior as is expected from arrays as specified in the bean spec in * section 7.2. * * @param bean * the bean object * @param propertyName * the name of the property * @param elementType * type of the elements in the set. If <code>null</code> and the * property is an array the type will be inferred. If * <code>null</code> and the property type cannot be inferred * element type will be <code>null</code>. * @return an observable set tracking the collection-typed named property of * the given bean object * @since 1.2 * * @deprecated use <code>BeanProperties</code> instead */ public static IObservableSet observeSet(Object bean, String propertyName, Class elementType) { return observeSet(Realm.getDefault(), bean, propertyName, elementType); } /** * Returns a factory for creating observable sets in the given realm, * tracking the given property of a particular bean object * * @param realm * the realm to use * @param propertyName * the name of the property * @param elementType * type of the elements in the set. If <code>null</code> and the * property is an array the type will be inferred. If * <code>null</code> and the property type cannot be inferred * element type will be <code>null</code>. * @return a factory for creating observable sets in the given realm, * tracking the given property of a particular bean object * * @deprecated use <code>BeanProperties</code> instead */ public static IObservableFactory setFactory(final Realm realm, final String propertyName, final Class elementType) { return BeanProperties.set(propertyName, elementType).setFactory(realm); } /** * Returns a factory for creating observable sets in the current default * realm, tracking the given property of a particular bean object * * @param propertyName * the name of the property * @param elementType * type of the elements in the set. If <code>null</code> and the * property is an array the type will be inferred. If * <code>null</code> and the property type cannot be inferred * element type will be <code>null</code>. * @return a factory for creating observable sets in the given realm, * tracking the given property of a particular bean object * @since 1.2 */ public static IObservableFactory setFactory(String propertyName, Class elementType) { return setFactory(Realm.getDefault(), propertyName, elementType); } /** * Returns a factory for creating an observable map. The factory, when * provided with an {@link IObservableSet}, will create an * {@link IObservableMap} in the same realm as the underlying set that * tracks the current values of the named property for the beans in the * given set. * * @param beanClass * the common base type of bean objects that may be in the set * @param propertyName * the name of the property. May be nested e.g. "parent.name" * @return a factory for creating {@link IObservableMap} objects * * @since 1.1 * * @deprecated use <code>BeanProperties</code> instead */ public static IObservableFactory setToMapFactory(final Class beanClass, final String propertyName) { return new IObservableFactory() { @Override public IObservable createObservable(Object target) { return observeMap((IObservableSet) target, beanClass, propertyName); } }; } /** * Returns a factory for creating an observable map. The factory, when * provided with a bean object, will create an {@link IObservableMap} in the * given realm that tracks the map-typed named property for the specified * bean. * * @param realm * the realm assigned to observables created by the returned * factory. * @param propertyName * the name of the property * @return a factory for creating {@link IObservableMap} objects. * @since 1.1 * * @deprecated use <code>BeanProperties</code> instead */ public static IObservableFactory mapPropertyFactory(final Realm realm, final String propertyName) { return BeanProperties.map(propertyName).mapFactory(realm); } /** * Returns a factory for creating an observable map. The factory, when * provided with a bean object, will create an {@link IObservableMap} in the * current default realm that tracks the map-typed named property for the * specified bean. * * @param propertyName * the name of the property * @return a factory for creating {@link IObservableMap} objects. * @since 1.2 * * @deprecated use <code>BeanProperties</code> instead */ public static IObservableFactory mapPropertyFactory(String propertyName) { return mapPropertyFactory(Realm.getDefault(), propertyName); } }