partition/src/main/java/net/sf/taverna/t2/partition/RootPartition.java - incubator-taverna-workbench - Git at Google

 /*******************************************************************************
  * Copyright (C) 2007 The University of Manchester
  *
  *  Modifications to the initial code base are copyright of their
  *  respective authors, or their employers as appropriate.
  *
  *  This program is free software; you can redistribute it and/or
  *  modify it under the terms of the GNU Lesser General Public License
  *  as published by the Free Software Foundation; either version 2.1 of
  *  the License, or (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful, but
  *  WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  *  Lesser General Public License for more details.
  *
  *  You should have received a copy of the GNU Lesser General Public
  *  License along with this program; if not, write to the Free Software
  *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
  ******************************************************************************/
 package net.sf.taverna.t2.partition;

 import java.util.ArrayList;
 import java.util.HashMap;
 import java.util.HashSet;
 import java.util.List;
 import java.util.Map;
 import java.util.Set;

 import javax.swing.SwingUtilities;
 import javax.swing.event.TreeModelEvent;
 import javax.swing.event.TreeModelListener;
 import javax.swing.tree.TreeModel;
 import javax.swing.tree.TreePath;

 /**
  * Subclass of Partition acting as the public access point for the partition
  * structure. Exposes a TreeModel for use with a UI.
  *
  * @author Tom Oinn
  *
  * @param <ItemType>
  *            all items added to this partition must cast to this type
  */
 public class RootPartition<ItemType extends Comparable> extends
 		Partition<ItemType, Object, Object> implements TreeModel {

 	// Used to track where we ended up putting items with the addOrUpdateItem
 	// method, this makes checking for duplicate items, reclassification and
 	// removal of partitions much faster at the expense of a few bytes of memory
 	private Map<ItemType, Partition<ItemType, ?, ?>> itemToLeafPartition;

 	private PropertyExtractorRegistry propertyExtractorRegistry;

 	private final SetModelChangeListener<ItemType> setChangeListener = new SetModelChangeListener<ItemType>() {

 		private List<Query<?>> queryList = new ArrayList<Query<?>>();

 		public void itemsWereAdded(Set<ItemType> newItems) {
 			for (ItemType item : newItems) {
 				addOrUpdateItem(item);
 			}
 		}

 		@SuppressWarnings("unchecked")
 		public void itemsWereRemoved(Set<Object> itemsRemoved) {
 			for (Object item : itemsRemoved) {
 				try {
 					removeItem((ItemType) item);
 				} catch (ClassCastException cce) {
 					// Obviously wasn't the right type of item but that means it
 					// couldn't have been added in the first place so we can
 					// safely ignore this.
 				}
 			}
 		}

 		public void addQuery(Query<?> query) {
 			queryList.add(query);
 		}

 		public List<Query<?>> getQueries() {
 			return queryList;
 		}

 	};

 	/**
 	 * Build a new empty root partition with the specified list of partition
 	 * algorithm implementations used to recursively allocate new data items to
 	 * the sub-partitions below this one on addition
 	 *
 	 * @param pa
 	 */
 	public RootPartition(List<PartitionAlgorithm<?>> pa,
 			PropertyExtractorRegistry per) {
 		super(null, pa, null, null);
 		this.root = this;
 		this.propertyExtractorRegistry = per;
 		this.itemToLeafPartition = new HashMap<ItemType, Partition<ItemType, ?, ?>>();
 	}

 	/**
 	 * The root partition comes with a convenience implementation of
 	 * SetModelChangeListener which can be used to attach it to a compliant
 	 * instance of SetModel (assuming the item types match). This allows the
 	 * SetModel to act as the backing data store for the partition - as Query
 	 * and the various subset / set union operators also implement this it
 	 * provides a relatively simple mechanism to link multiple sets of data to
 	 * this partition.
 	 */
 	public SetModelChangeListener<ItemType> getSetModelChangeListener() {
 		return this.setChangeListener;
 	}

 	/**
 	 * Alter the list of partition algorithms which drive the construction of
 	 * the partitions. Calling this effectively forces a complete rebuild of the
 	 * tree structure which is an expensive operation so be careful when you use
 	 * it.
 	 *
 	 * @param pa
 	 *            a new list of PartitionAlgorithmSPI instances to use as the
 	 *            basis for the partition structure.
 	 */
 	public synchronized void setPartitionAlgorithmList(
 			List<PartitionAlgorithm<?>> pa) {
 		if (pa.equals(this.partitionAlgorithms)) {
 			// At the least this checks for reference equality, although I'm not
 			// sure it does much more than that. TODO - replace this with a
 			// smarter check to see whether the list has really changed, doing a
 			// full re-build is expensive.
 			return;
 		}
 		// First create a copy of the keyset containing all the items we've
 		// added to this point.
 		Set<ItemType> itemsToAdd = new HashSet<ItemType>(itemToLeafPartition
 				.keySet());
 		this.partitionAlgorithms = pa;
 		this.children.clear();
 		this.itemToLeafPartition.clear();
 		treeStructureChanged(new TreeModelEvent(this, getTreePath()));
 		for (ItemType item : itemsToAdd) {
 			addOrUpdateItem(item);
 		}
 		sortChildPartitions();
 	}

 	/**
 	 * Add a new item to the partition structure. If the item already exists
 	 * this is interpreted as a request to reclassify according to properties
 	 * which may have changed. This is not the same as a reclassification due to
 	 * modification of the partition algorithm list, and just refers to the
 	 * specified item. If the item exists already and its classification is
 	 * changed the model will be notified with a removal event from the previous
 	 * location and the item will be added as usual immediately afterwards.
 	 */
 	public synchronized void addOrUpdateItem(ItemType item) {
 		// First check whether the item is already stored
 		if (itemToLeafPartition.containsKey(item)) {
 			// request to reclassify item.
 			List<Partition<ItemType, ?, ?>> partitions = itemToLeafPartition
 					.get(item).getPartitionPath();
 			// partitions[i].getPartitionValue is the result of running
 			// getPartitionAlgorithms[i-1] on the item, we run through the array
 			// until either we hit the end (no reclassification) or the item
 			// classifies differently in which case we remove and re-add it.
 			for (int i = 1; i < partitions.size(); i++) {
 				PartitionAlgorithm<?> pa = getPartitionAlgorithms().get(
 						i - 1);
 				Object existingValue = partitions.get(i).getPartitionValue();
 				Object reclassifiedValue = pa.allocate(item,
 						getPropertyExtractorRegistry());
 				if (existingValue.equals(reclassifiedValue) == false) {
 					// Items classify differently, remove it
 					removeItem(item);
 					// ...and add it back again, forcing reclassification
 					super.addItem(item);
 					return;
 				}
 			}
 			// return as the item wasn't changed.
 			return;
 		} else {
 			// Value wasn't already in the map so we just add it as usual
 			super.addItem(item);
 		}

 	}

 	/**
 	 * Remove an item from the partition structure, if this leaves any
 	 * partitions with zero item count they are removed as well to keep things
 	 * tidy.
 	 *
 	 * @param item
 	 *            the item to remove from the partition structure. If this isn't
 	 *            present in the structure this method does nothing along the
 	 *            lines of the collections API.
 	 */
 	public synchronized void removeItem(ItemType item) {
 		Partition<ItemType, ?, ?> partition = itemToLeafPartition.get(item);
 		if (partition != null) {
 			// Remove the item from the leaf partition
 			int previousIndex = partition.getMembers().indexOf(item);
 			TreePath pathToPartition = partition.getTreePath();
 			//partition.removeMember(item);
 			for (Partition<ItemType, ?, ?> parentPathElement : partition
 					.getPartitionPath()) {
 				// Notify path to root that the number of members
 				// has changed and it should update the renderers of
 				// any attached trees
 				treeNodesChanged(new TreeModelEvent(this, parentPathElement
 						.getTreePath()));
 			}
 			partition.removeMember(item);
 			treeNodesRemoved(new TreeModelEvent(this, pathToPartition,
 					new int[] { previousIndex }, new Object[] { item }));
 			// Traverse up the partition path and decrement the item count. If
 			// any item count becomes zero we mark this as a partition to
 			// remove, then at the end we remove the highest level one (so we
 			// only have to send a single delete event to the tree view)
 			for (Partition<ItemType, ?, ?> p : partition.getPartitionPath()) {
 				synchronized (p) {
 					p.itemCount--;
 					if (p.getItemCount() == 0 && p != this) {
 						// Can remove this node, all nodes after this will by
 						// definition have item count of zero. The exception is
 						// if this is the root node, in which case we just
 						// ignore it and move on to the next child. This avoids
 						// deleting the root, which is generally not a smart
 						// thing to do to a tree.
 						Partition<ItemType, ?, ?> parent = p.getParent();
 						int indexInParent = getIndexOfChild(parent, p);
 						parent.children.remove(indexInParent);
 						treeNodesRemoved(new TreeModelEvent(this, parent
 								.getTreePath(), new int[] { indexInParent },
 								new Object[] { p }));

 						break;
 					}
 				}
 			}
 			itemToLeafPartition.remove(item);
 		}
 		treeStructureChanged(new TreeModelEvent(this,getTreePath()));
 	}

 	/**
 	 * Called by a leaf Partition when it has stored an item in its member set,
 	 * used to keep track of where items have been stored to make removal more
 	 * efficient.
 	 */
 	void itemStoredAt(ItemType item, Partition<ItemType, ?, ?> partition) {
 		itemToLeafPartition.put(item, partition);
 	}

 	// ---------------------//
 	// TreeModel interfaces //
 	// ---------------------//
 	private List<TreeModelListener> treeListeners = new ArrayList<TreeModelListener>();

 	@SuppressWarnings("unchecked")
 	public synchronized Object getChild(Object parent, int index) {
 		if (parent instanceof Partition) {
 			Partition<ItemType, ?, ?> p = (Partition<ItemType, ?, ?>) parent;
 			if (p.getMembers().isEmpty() == false) {
 				if (index < 0 || index >= p.getMembers().size()) {
 					return null;
 				} else {
 					return p.getMembers().get(index);
 				}
 			} else {
 				if (index < 0 || index >= p.getChildren().size()) {
 					return null;
 				} else {
 					return p.getChildren().get(index);
 				}
 			}
 		}
 		return null;
 	}

 	@SuppressWarnings("unchecked")
 	public synchronized int getChildCount(Object parent) {
 		if (parent instanceof Partition) {
 			Partition<ItemType, ?, ?> p = (Partition<ItemType, ?, ?>) parent;
 			if (p.getMembers().isEmpty() == false) {
 				return p.getMembers().size();
 			}
 			return p.getChildren().size();
 		}
 		return 0;
 	}

 	@SuppressWarnings("unchecked")
 	public synchronized int getIndexOfChild(Object parent, Object child) {
 		if (parent != null && child != null && parent instanceof Partition
 				&& child instanceof Partition) {
 			Partition<ItemType, ?, ?> p = (Partition<ItemType, ?, ?>) parent;
 			Partition<ItemType, ?, ?> c = (Partition<ItemType, ?, ?>) child;
 			if (p.root == c.root && p.root == this) {
 				// Parent and child must both be members of this tree structure
 				return p.getChildren().indexOf(child);
 			}
 		} else if (parent != null && child != null
 				&& parent instanceof Partition) {
 			Partition<ItemType, ?, ?> p = (Partition<ItemType, ?, ?>) parent;
 			return p.getMembers().indexOf(child);
 		}
 		return -1;

 	}

 	public Object getRoot() {
 		// The root partition is also the root of the tree model
 		return this;
 	}

 	public boolean isLeaf(Object node) {
 		// No leaves at the moment as we're only considering partitions which
 		// are by definition not leaves (the items within the last partition are
 		// but at the moment we're not including them in the tree model)
 		return (!(node instanceof Partition));
 	}

 	public void removeTreeModelListener(TreeModelListener l) {
 		treeListeners.remove(l);
 	}

 	public void addTreeModelListener(TreeModelListener l) {
 		if (treeListeners.contains(l) == false) {
 			treeListeners.add(l);
 		}
 	}

 	public void valueForPathChanged(TreePath path, Object newValue) {
 		// Ignore this, the tree values are never changed by the user in this
 		// implementation so we don't have to do anything
 	}

 	// -------------------------------------------------------//
 	// Tree event forwarding helper methods used by Partition //
 	// -------------------------------------------------------//

 	void treeNodesChanged(final TreeModelEvent e) {
 		SwingUtilities.invokeLater(new Runnable() {
 			public void run() {
 				for (TreeModelListener listener : new ArrayList<TreeModelListener>(
 						treeListeners)) {
 					listener.treeNodesChanged(e);
 				}
 			}
 		});
 	}

 	void treeNodesInserted(final TreeModelEvent e) {
 		SwingUtilities.invokeLater(new Runnable() {
 			public void run() {
 				for (TreeModelListener listener : new ArrayList<TreeModelListener>(
 						treeListeners)) {
 					listener.treeNodesInserted(e);
 				}
 			}
 		});
 	}

 	void treeNodesRemoved(final TreeModelEvent e) {
 		SwingUtilities.invokeLater(new Runnable() {
 			public void run() {
 				for (TreeModelListener listener : new ArrayList<TreeModelListener>(
 						treeListeners)) {
 					listener.treeNodesRemoved(e);
 				}
 			}
 		});
 	}

 	void treeStructureChanged(final TreeModelEvent e) {
 		SwingUtilities.invokeLater(new Runnable() {
 			public void run() {
 				for (TreeModelListener listener : new ArrayList<TreeModelListener>(
 						treeListeners)) {
 					listener.treeStructureChanged(e);
 				}
 			}
 		});
 	}

 	public PropertyExtractorRegistry getPropertyExtractorRegistry() {
 		return this.propertyExtractorRegistry;
 	}

 }
	/*******************************************************************************
	* Copyright (C) 2007 The University of Manchester
	*
	* Modifications to the initial code base are copyright of their
	* respective authors, or their employers as appropriate.
	*
	* This program is free software; you can redistribute it and/or
	* modify it under the terms of the GNU Lesser General Public License
	* as published by the Free Software Foundation; either version 2.1 of
	* the License, or (at your option) any later version.
	*
	* This program is distributed in the hope that it will be useful, but
	* WITHOUT ANY WARRANTY; without even the implied warranty of
	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
	* Lesser General Public License for more details.
	*
	* You should have received a copy of the GNU Lesser General Public
	* License along with this program; if not, write to the Free Software
	* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
	******************************************************************************/
	package net.sf.taverna.t2.partition;

	import java.util.ArrayList;
	import java.util.HashMap;
	import java.util.HashSet;
	import java.util.List;
	import java.util.Map;
	import java.util.Set;

	import javax.swing.SwingUtilities;
	import javax.swing.event.TreeModelEvent;
	import javax.swing.event.TreeModelListener;
	import javax.swing.tree.TreeModel;
	import javax.swing.tree.TreePath;

	/**
	* Subclass of Partition acting as the public access point for the partition
	* structure. Exposes a TreeModel for use with a UI.
	*
	* @author Tom Oinn
	*
	* @param <ItemType>
	* all items added to this partition must cast to this type
	*/
	public class RootPartition<ItemType extends Comparable> extends
	Partition<ItemType, Object, Object> implements TreeModel {

	// Used to track where we ended up putting items with the addOrUpdateItem
	// method, this makes checking for duplicate items, reclassification and
	// removal of partitions much faster at the expense of a few bytes of memory
	private Map<ItemType, Partition<ItemType, ?, ?>> itemToLeafPartition;

	private PropertyExtractorRegistry propertyExtractorRegistry;

	private final SetModelChangeListener<ItemType> setChangeListener = new SetModelChangeListener<ItemType>() {

	private List<Query<?>> queryList = new ArrayList<Query<?>>();

	public void itemsWereAdded(Set<ItemType> newItems) {
	for (ItemType item : newItems) {
	addOrUpdateItem(item);
	}
	}

	@SuppressWarnings("unchecked")
	public void itemsWereRemoved(Set<Object> itemsRemoved) {
	for (Object item : itemsRemoved) {
	try {
	removeItem((ItemType) item);
	} catch (ClassCastException cce) {
	// Obviously wasn't the right type of item but that means it
	// couldn't have been added in the first place so we can
	// safely ignore this.
	}
	}
	}

	public void addQuery(Query<?> query) {
	queryList.add(query);
	}

	public List<Query<?>> getQueries() {
	return queryList;
	}

	};

	/**
	* Build a new empty root partition with the specified list of partition
	* algorithm implementations used to recursively allocate new data items to
	* the sub-partitions below this one on addition
	*
	* @param pa
	*/
	public RootPartition(List<PartitionAlgorithm<?>> pa,
	PropertyExtractorRegistry per) {
	super(null, pa, null, null);
	this.root = this;
	this.propertyExtractorRegistry = per;
	this.itemToLeafPartition = new HashMap<ItemType, Partition<ItemType, ?, ?>>();
	}

	/**
	* The root partition comes with a convenience implementation of
	* SetModelChangeListener which can be used to attach it to a compliant
	* instance of SetModel (assuming the item types match). This allows the
	* SetModel to act as the backing data store for the partition - as Query
	* and the various subset / set union operators also implement this it
	* provides a relatively simple mechanism to link multiple sets of data to
	* this partition.
	*/
	public SetModelChangeListener<ItemType> getSetModelChangeListener() {
	return this.setChangeListener;
	}

	/**
	* Alter the list of partition algorithms which drive the construction of
	* the partitions. Calling this effectively forces a complete rebuild of the
	* tree structure which is an expensive operation so be careful when you use
	* it.
	*
	* @param pa
	* a new list of PartitionAlgorithmSPI instances to use as the
	* basis for the partition structure.
	*/
	public synchronized void setPartitionAlgorithmList(
	List<PartitionAlgorithm<?>> pa) {
	if (pa.equals(this.partitionAlgorithms)) {
	// At the least this checks for reference equality, although I'm not
	// sure it does much more than that. TODO - replace this with a
	// smarter check to see whether the list has really changed, doing a
	// full re-build is expensive.
	return;
	}
	// First create a copy of the keyset containing all the items we've
	// added to this point.
	Set<ItemType> itemsToAdd = new HashSet<ItemType>(itemToLeafPartition
	.keySet());
	this.partitionAlgorithms = pa;
	this.children.clear();
	this.itemToLeafPartition.clear();
	treeStructureChanged(new TreeModelEvent(this, getTreePath()));
	for (ItemType item : itemsToAdd) {
	addOrUpdateItem(item);
	}
	sortChildPartitions();
	}

	/**
	* Add a new item to the partition structure. If the item already exists
	* this is interpreted as a request to reclassify according to properties
	* which may have changed. This is not the same as a reclassification due to
	* modification of the partition algorithm list, and just refers to the
	* specified item. If the item exists already and its classification is
	* changed the model will be notified with a removal event from the previous
	* location and the item will be added as usual immediately afterwards.
	*/
	public synchronized void addOrUpdateItem(ItemType item) {
	// First check whether the item is already stored
	if (itemToLeafPartition.containsKey(item)) {
	// request to reclassify item.
	List<Partition<ItemType, ?, ?>> partitions = itemToLeafPartition
	.get(item).getPartitionPath();
	// partitions[i].getPartitionValue is the result of running
	// getPartitionAlgorithms[i-1] on the item, we run through the array
	// until either we hit the end (no reclassification) or the item
	// classifies differently in which case we remove and re-add it.
	for (int i = 1; i < partitions.size(); i++) {
	PartitionAlgorithm<?> pa = getPartitionAlgorithms().get(
	i - 1);
	Object existingValue = partitions.get(i).getPartitionValue();
	Object reclassifiedValue = pa.allocate(item,
	getPropertyExtractorRegistry());
	if (existingValue.equals(reclassifiedValue) == false) {
	// Items classify differently, remove it
	removeItem(item);
	// ...and add it back again, forcing reclassification
	super.addItem(item);
	return;
	}
	}
	// return as the item wasn't changed.
	return;
	} else {
	// Value wasn't already in the map so we just add it as usual
	super.addItem(item);
	}

	}

	/**
	* Remove an item from the partition structure, if this leaves any
	* partitions with zero item count they are removed as well to keep things
	* tidy.
	*
	* @param item
	* the item to remove from the partition structure. If this isn't
	* present in the structure this method does nothing along the
	* lines of the collections API.
	*/
	public synchronized void removeItem(ItemType item) {
	Partition<ItemType, ?, ?> partition = itemToLeafPartition.get(item);
	if (partition != null) {
	// Remove the item from the leaf partition
	int previousIndex = partition.getMembers().indexOf(item);
	TreePath pathToPartition = partition.getTreePath();
	//partition.removeMember(item);
	for (Partition<ItemType, ?, ?> parentPathElement : partition
	.getPartitionPath()) {
	// Notify path to root that the number of members
	// has changed and it should update the renderers of
	// any attached trees
	treeNodesChanged(new TreeModelEvent(this, parentPathElement
	.getTreePath()));
	}
	partition.removeMember(item);
	treeNodesRemoved(new TreeModelEvent(this, pathToPartition,
	new int[] { previousIndex }, new Object[] { item }));
	// Traverse up the partition path and decrement the item count. If
	// any item count becomes zero we mark this as a partition to
	// remove, then at the end we remove the highest level one (so we
	// only have to send a single delete event to the tree view)
	for (Partition<ItemType, ?, ?> p : partition.getPartitionPath()) {
	synchronized (p) {
	p.itemCount--;
	if (p.getItemCount() == 0 && p != this) {
	// Can remove this node, all nodes after this will by
	// definition have item count of zero. The exception is
	// if this is the root node, in which case we just
	// ignore it and move on to the next child. This avoids
	// deleting the root, which is generally not a smart
	// thing to do to a tree.
	Partition<ItemType, ?, ?> parent = p.getParent();
	int indexInParent = getIndexOfChild(parent, p);
	parent.children.remove(indexInParent);
	treeNodesRemoved(new TreeModelEvent(this, parent
	.getTreePath(), new int[] { indexInParent },
	new Object[] { p }));

	break;
	}
	}
	}
	itemToLeafPartition.remove(item);
	}
	treeStructureChanged(new TreeModelEvent(this,getTreePath()));
	}

	/**
	* Called by a leaf Partition when it has stored an item in its member set,
	* used to keep track of where items have been stored to make removal more
	* efficient.
	*/
	void itemStoredAt(ItemType item, Partition<ItemType, ?, ?> partition) {
	itemToLeafPartition.put(item, partition);
	}

	// ---------------------//
	// TreeModel interfaces //
	// ---------------------//
	private List<TreeModelListener> treeListeners = new ArrayList<TreeModelListener>();

	@SuppressWarnings("unchecked")
	public synchronized Object getChild(Object parent, int index) {
	if (parent instanceof Partition) {
	Partition<ItemType, ?, ?> p = (Partition<ItemType, ?, ?>) parent;
	if (p.getMembers().isEmpty() == false) {
	if (index < 0 \|\| index >= p.getMembers().size()) {
	return null;
	} else {
	return p.getMembers().get(index);
	}
	} else {
	if (index < 0 \|\| index >= p.getChildren().size()) {
	return null;
	} else {
	return p.getChildren().get(index);
	}
	}
	}
	return null;
	}

	@SuppressWarnings("unchecked")
	public synchronized int getChildCount(Object parent) {
	if (parent instanceof Partition) {
	Partition<ItemType, ?, ?> p = (Partition<ItemType, ?, ?>) parent;
	if (p.getMembers().isEmpty() == false) {
	return p.getMembers().size();
	}
	return p.getChildren().size();
	}
	return 0;
	}

	@SuppressWarnings("unchecked")
	public synchronized int getIndexOfChild(Object parent, Object child) {
	if (parent != null && child != null && parent instanceof Partition
	&& child instanceof Partition) {
	Partition<ItemType, ?, ?> p = (Partition<ItemType, ?, ?>) parent;
	Partition<ItemType, ?, ?> c = (Partition<ItemType, ?, ?>) child;
	if (p.root == c.root && p.root == this) {
	// Parent and child must both be members of this tree structure
	return p.getChildren().indexOf(child);
	}
	} else if (parent != null && child != null
	&& parent instanceof Partition) {
	Partition<ItemType, ?, ?> p = (Partition<ItemType, ?, ?>) parent;
	return p.getMembers().indexOf(child);
	}
	return -1;

	}

	public Object getRoot() {
	// The root partition is also the root of the tree model
	return this;
	}

	public boolean isLeaf(Object node) {
	// No leaves at the moment as we're only considering partitions which
	// are by definition not leaves (the items within the last partition are
	// but at the moment we're not including them in the tree model)
	return (!(node instanceof Partition));
	}

	public void removeTreeModelListener(TreeModelListener l) {
	treeListeners.remove(l);
	}

	public void addTreeModelListener(TreeModelListener l) {
	if (treeListeners.contains(l) == false) {
	treeListeners.add(l);
	}
	}

	public void valueForPathChanged(TreePath path, Object newValue) {
	// Ignore this, the tree values are never changed by the user in this
	// implementation so we don't have to do anything
	}

	// -------------------------------------------------------//
	// Tree event forwarding helper methods used by Partition //
	// -------------------------------------------------------//

	void treeNodesChanged(final TreeModelEvent e) {
	SwingUtilities.invokeLater(new Runnable() {
	public void run() {
	for (TreeModelListener listener : new ArrayList<TreeModelListener>(
	treeListeners)) {
	listener.treeNodesChanged(e);
	}
	}
	});
	}

	void treeNodesInserted(final TreeModelEvent e) {
	SwingUtilities.invokeLater(new Runnable() {
	public void run() {
	for (TreeModelListener listener : new ArrayList<TreeModelListener>(
	treeListeners)) {
	listener.treeNodesInserted(e);
	}
	}
	});
	}

	void treeNodesRemoved(final TreeModelEvent e) {
	SwingUtilities.invokeLater(new Runnable() {
	public void run() {
	for (TreeModelListener listener : new ArrayList<TreeModelListener>(
	treeListeners)) {
	listener.treeNodesRemoved(e);
	}
	}
	});
	}

	void treeStructureChanged(final TreeModelEvent e) {
	SwingUtilities.invokeLater(new Runnable() {
	public void run() {
	for (TreeModelListener listener : new ArrayList<TreeModelListener>(
	treeListeners)) {
	listener.treeStructureChanged(e);
	}
	}
	});
	}

	public PropertyExtractorRegistry getPropertyExtractorRegistry() {
	return this.propertyExtractorRegistry;
	}

	}