/*
      Copyright 2009 Ramon Servadei
   
      Licensed under the Apache License, Version 2.0 (the "License");
      you may not use this file except in compliance with the License.
      You may obtain a copy of the License at
   
          http://www.apache.org/licenses/LICENSE-2.0
   
     Unless required by applicable law or agreed to in writing, software
     distributed under the License is distributed on an "AS IS" BASIS,
     WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
     See the License for the specific language governing permissions and
     limitations under the License.
   */
  package fulmine.ui;
  
  import static fulmine.util.Utils.EMPTY_STRING;
  
  import java.awt.Color;
  import java.awt.Component;
  import java.util.ArrayList;
  import java.util.Collection;
  import java.util.Enumeration;
  import java.util.Iterator;
  import java.util.List;
  import java.util.Map;
  import java.util.Set;
  import java.util.Timer;
  import java.util.TimerTask;
  import java.util.Map.Entry;
  
  import javax.swing.AbstractCellEditor;
  import javax.swing.JComponent;
  import javax.swing.JLabel;
  import javax.swing.JTable;
  import javax.swing.SwingUtilities;
  import javax.swing.table.AbstractTableModel;
  import javax.swing.table.TableCellEditor;
  import javax.swing.table.TableCellRenderer;
  import javax.swing.table.TableColumn;
  
  import org.apache.commons.logging.Log;
  
  import fulmine.IType;
  import fulmine.Type;
  import fulmine.context.IFulmineContext;
  import fulmine.event.EventFrameExecution;
  import fulmine.event.IEvent;
  import fulmine.event.IEventSource;
  import fulmine.event.listener.EventListenerUtils;
  import fulmine.event.listener.IEventListener;
  import fulmine.model.container.IContainer;
  import fulmine.model.container.IContainer.DataState;
  import fulmine.model.container.events.ContainerFieldAddedEvent;
  import fulmine.model.container.events.ContainerFieldRemovedEvent;
  import fulmine.model.container.events.ContainerStateChangeEvent;
  import fulmine.model.container.impl.Record;
  import fulmine.model.field.IField;
  import fulmine.model.field.StringField;
  import fulmine.model.field.containerdefinition.ContainerDefinitionField;
  import fulmine.ui.field.AbstractFieldUI;
  import fulmine.ui.field.BooleanFieldUI;
  import fulmine.ui.field.DoubleFieldUI;
  import fulmine.ui.field.FloatFieldUI;
  import fulmine.ui.field.IFieldUI;
  import fulmine.ui.field.IntegerFieldUI;
  import fulmine.ui.field.LongFieldUI;
  import fulmine.ui.field.StringFieldUI;
  import fulmine.util.Utils;
  import fulmine.util.collection.CollectionFactory;
  import fulmine.util.log.AsyncLog;
  import fulmine.util.reference.AutoCreatingStore;
  import fulmine.util.reference.IAutoCreatingStore;
  import fulmine.util.reference.IObjectBuilder;
  
  /**
   * A table that can render {@link Record} instances as rows. The table
   * dynamically adds and removes columns as records it shows have new
   * {@link IField}s added and removed. A column is only removed if there are no
   * records that contain the field the column is linked to.
   * <p>
   * All cells are editable. If the record is local, the field behind the cell is
   * updated via its {@link IField#setValueFromString} method. Remote records will
   * have their field value set via a call to
   * {@link IFulmineContext#updateRemoteContainer(String, String, IType, fulmine.IDomain, String, String)}
   * <p>
   * The table itself is an {@link IEventListener} so can be used as the listener
   * for record subscriptions. It is thread safe for handling updates from the
   * {@link IFulmineContext} framework - they are spun off onto the AWT thread for
   * processing.
   * <p>
   * This table is intended as a demonstration for building more sophisticated
   * table-based UIs based on the {@link IFulmineContext} framework.
   * <p>
   * Note: the column for a field that has been removed from all containers is
   * still shown in the UI.
   * 
   * @author Ramon Servadei
  */
 @SuppressWarnings("unchecked")
 public class RecordTable extends JTable implements IEventListener
 {
     private final static Log LOG = new AsyncLog(RecordTable.class);
 
     /** Serial version */
     private static final long serialVersionUID = 1L;
 
     /**
      * This expresses the constituent parts that form the address of a record.
      * 
      * @see Record#getAddressable()
      */
     private enum Address
     {
         name, type, domain, context
     }
 
     /**
      * Holds the {@link IFieldUI} per {@link IType}
      */
     private final static IAutoCreatingStore<IType, IFieldUI> UIStore =
         new AutoCreatingStore<IType, IFieldUI>(
             new IObjectBuilder<IType, IFieldUI>()
             {
                 public IFieldUI create(IType key)
                 {
                     try
                     {
                         return (IFieldUI) fieldUIClassPerType.get(key).newInstance();
                     }
                     catch (Exception e)
                     {
                         throw new IllegalStateException(
                             "Could not create the AbstractFieldUI for type "
                                 + key, e);
                     }
                 }
             });
 
     /** The {@link IFieldUI} that renders each field type */
     static final Map<IType, Class> fieldUIClassPerType =
         CollectionFactory.newMap();
     static
     {
         fieldUIClassPerType.put(Type.BOOLEAN_FIELD, BooleanFieldUI.class);
         fieldUIClassPerType.put(Type.INTEGER_FIELD, IntegerFieldUI.class);
         fieldUIClassPerType.put(Type.LONG_FIELD, LongFieldUI.class);
         fieldUIClassPerType.put(Type.FLOAT_FIELD, FloatFieldUI.class);
         fieldUIClassPerType.put(Type.DOUBLE_FIELD, DoubleFieldUI.class);
         fieldUIClassPerType.put(Type.STRING_FIELD, StringFieldUI.class);
     }
 
     /**
      * Handles all subscribed records as the model for the
      * {@link #RecordTable()}.
      * <p>
      * This is not thread safe and should only be accessed via the Swing AWT
      * thread.
      * 
      * @author Ramon Servadei
      */
     class RecordTableModel extends AbstractTableModel implements IEventListener
     {
 
         /** Serial version */
         private static final long serialVersionUID = 1L;
 
         /** Holds all the records for the model */
         private final List<Record> records;
 
         /** Holds the index for each distinct record field name */
         private final List<String> fieldIndexes;
 
         /** Holds the set of field names across all the records */
         private final Set<String> fieldNames;
 
         /**
          * Standard constructor
          */
         public RecordTableModel()
         {
             super();
             this.records = CollectionFactory.newList(1);
             this.fieldIndexes = CollectionFactory.newList(3);
             this.fieldNames = CollectionFactory.newSet(3);
 
             // add the address columns
             final Address[] values = Address.values();
             for (Address address : values)
             {
                 addColumn(new StringField(address.toString()));
             }
         }
 
         public int getColumnCount()
         {
             return getFieldIndexes().size();
         }
 
         public int getRowCount()
         {
             return getRecords().size();
         }
 
         public Object getValueAt(int rowIndex, int columnIndex)
         {
             if (columnIndex >= getFieldIndexes().size())
             {
                 return "";
             }
             final Record record = getRecords().get(rowIndex);
             // process system address columns first
             if (columnIndex == Address.name.ordinal())
             {
                 return record.getIdentity();
             }
             if (columnIndex == Address.domain.ordinal())
             {
                 return record.getDomain().getName();
             }
             if (columnIndex == Address.type.ordinal())
             {
                 return record.getType().getName();
             }
             if (columnIndex == Address.context.ordinal())
             {
                 return record.getNativeContextIdentity();
             }
             IField field = record.get(getFieldIndexes().get(columnIndex));
             if (field == null)
             {
                 return "";
             }
             /*
              * it may be more efficient to pass back the field and let the
              * renderer handle the field value
              */
             return field.getValueAsString();
         }
 
         @Override
         public String getColumnName(int column)
         {
             return getFieldIndexes().get(column);
         }
 
         /**
          * Tracks the formats of the rows and columns. The inner list is for the
          * columns.
          */
         Map<Integer, List<Format>> formats = CollectionFactory.newMap();
 
         /**
          * @return the formats for the rows and columns. The inner list is for
          *         the columns.
          */
         Map<Integer, List<Format>> getFormats()
         {
             return this.formats;
         }
 
         void addColumn(IField field)
         {
             if (field instanceof ContainerDefinitionField)
             {
                 // we don't want to display the container definition
                 return;
             }
             final String identity = field.getIdentity();
             getFieldIndexes().add(identity);
             getFieldNames().add(identity);
             final Set<Entry<Integer, List<Format>>> entrySet =
                 formats.entrySet();
             for (Entry<Integer, List<Format>> entry : entrySet)
             {
                 entry.getValue().add(new Format());
             }
             fireTableStructureChanged();
         }
 
         void deleteColumn(IField field)
         {
             final String identity = field.getIdentity();
             final int index = getFieldIndexes().indexOf(identity);
             getFieldIndexes().remove(index);
             getFieldNames().remove(identity);
             final Set<Entry<Integer, List<Format>>> entrySet =
                 formats.entrySet();
             for (Entry<Integer, List<Format>> entry : entrySet)
             {
                 entry.getValue().remove(index);
             }
             fireTableStructureChanged();
         }
 
         @Override
         public final int hashCode()
         {
             return super.hashCode();
         }
 
         @Override
         public final boolean equals(Object obj)
         {
             return super.equals(obj);
         }
 
         @Override
         public String toString()
         {
             final SwingWorker<String> worker = new SwingWorker<String>()
             {
                 @Override
                 public String doWork() throws Exception
                 {
                     return getRecords().toString();
                 }
             };
             return worker.invokeAndWait().getResult();
         }
 
         public void addedAsListenerFor(IEventSource source)
         {
             // noop
         }
 
         public Class<? extends IEvent>[] getEventTypeFilter()
         {
             return eventFilter;
         }
 
         public void removedAsListenerFrom(IEventSource source)
         {
             // noop
         }
 
         public void update(final IEvent event)
         {
             /*
              * All update logic is done in the Swing thread to avoid concurrency
              * issues. This may be tuned to get better performance out of the UI
              * at a later time.
              */
             SwingUtilities.invokeLater(new Runnable()
             {
                 public void run()
                 {
                     if (event instanceof Record)
                     {
                         handle((Record) event);
                         return;
                     }
                     if (event instanceof ContainerStateChangeEvent)
                     {
                         handle((ContainerStateChangeEvent) event);
                         return;
                     }
                     if (event instanceof ContainerFieldAddedEvent)
                     {
                         handle((ContainerFieldAddedEvent) event);
                         return;
                     }
                     if (event instanceof ContainerFieldRemovedEvent)
                     {
                         handle((ContainerFieldRemovedEvent) event);
                         return;
                     }
                     if (LOG.isDebugEnabled())
                     {
                         LOG.debug("Unhandled event: "
                             + Utils.safeToString(event));
                     }
                 }
             });
         }
 
         /**
          * Handle a field removed from a container
          * 
          * @param event
          *            the event encapsulating the field removal
          */
         void handle(ContainerFieldRemovedEvent event)
         {
             // field deleted, but is the field available for any other records?
             boolean found = false;
             for (Record other : getRecords())
             {
                 if (!other.getAddress().equals(event.getSource().getAddress())
                     && other.contains(event.getField().getIdentity()))
                 {
                     // we found a record that has this field
                     found = true;
                     break;
                 }
             }
             if (!found)
             {
                 // ok to remove
                 deleteColumn(event.getField());
             }
         }
 
         /**
          * Handle a field added to a container
          * 
          * @param event
          *            the event encapsulating the field addition
          */
         void handle(ContainerFieldAddedEvent event)
         {
             if (!getFieldNames().contains(event.getField().getIdentity()))
             {
                 // new field
                 addColumn(event.getField());
             }
         }
 
         /**
          * Handle a record state change event.
          * 
          * @param event
          *            the record state change event
          */
         void handle(ContainerStateChangeEvent event)
         {
             if (event.getNewState() == DataState.STALE)
             {
                 // remove it
                 final int index = getRecords().indexOf(event.getSource());
                 getRecords().remove(index);
                 fireTableRowsDeleted(index, index);
             }
         }
 
         /**
          * Handle a change to a record
          * 
          * @param record
          *            the record
          */
         @SuppressWarnings("boxing")
         void handle(Record record)
         {
             // ignore destroyed container events
             if (!record.isActive())
             {
                 return;
             }
             final Collection<IField> changedFields = record.getChangedFields();
             /*
              * Test for new fields, this happens when we subscribe for a new
              * record that already exists as a subscription
              */
             for (IField field : changedFields)
             {
                 if (!getFieldNames().contains(field.getIdentity()))
                 {
                     // new field
                     addColumn(field);
                 }
             }
             // now replace the record instance with this one
             int index = getRecords().indexOf(record);
             if (index > -1)
             {
                 getRecords().set(index, record);
                 if (changedFields.size() == 0)
                 {
                     fireTableRowsUpdated(index, index);
                 }
                 else
                 {
                     for (IField field : changedFields)
                     {
                         final int col =
                             getFieldIndexes().indexOf(field.getIdentity());
                         cellUpdated(index, col);
                         fireTableCellUpdated(index, col);
                     }
                 }
             }
             else
             {
                 // this is a new record
                 getRecords().add(record);
                 index = getRecords().indexOf(record);
                 final ArrayList<Format> columnFormats =
                     new ArrayList<Format>(1);
                 for (int i = 0; i < fieldIndexes.size(); i++)
                 {
                     columnFormats.add(new Format());
                 }
                 formats.put(index, columnFormats);
                 fireTableRowsInserted(index, index);
             }
         }
 
         @SuppressWarnings("boxing")
         private void cellUpdated(int row, int col)
         {
             RecordTable.this.updateHandler.getUpdated().get(row).add(col);
         }
 
         /**
          * This set holds all the field names across all records
          * 
          * @return the set of field names across all records
          */
         Set<String> getFieldNames()
         {
             return this.fieldNames;
         }
 
         /**
          * This list holds all the field names used across all records in the
          * model. The position of each name in the list is the index of that
          * field in the model.
          * 
          * @return the list of all distinct field names used across all records
          */
         List<String> getFieldIndexes()
         {
             return this.fieldIndexes;
         }
 
         /**
          * This is the list of all records.
          * 
          * @return the list of all records for the model
          */
         List<Record> getRecords()
         {
             return this.records;
         }
     }
 
     private static final Color SELECTED_COLOUR = new Color(200, 200, 120);
 
     /**
      * Holds the formats to use for the table cells.
      * 
      * @author Ramon Servadei
      */
     class Format
     {
 
         private boolean update;
 
         private boolean opaque = true;
 
         private Color background;
 
         private Color selectedBackground = SELECTED_COLOUR;
 
         public Color getUpdateBackground()
         {
             return Color.CYAN;
         }
 
         public Color getBackground(boolean isSelected)
         {
             if (this.isUpdate())
             {
                 return getUpdateBackground();
             }
             if (isSelected)
             {
                 return getSelectedBackground();
             }
             return this.background;
         }
 
         public boolean isOpaque()
         {
             return this.opaque;
         }
 
         public void setBackground(Color background)
         {
             this.background = background;
         }
 
         public void setOpaque(boolean opaque)
         {
             this.opaque = opaque;
         }
 
         boolean isUpdate()
         {
             return this.update;
         }
 
         void setUpdate(boolean update)
         {
             this.update = update;
         }
 
         public Color getSelectedBackground()
         {
             return this.selectedBackground;
         }
     }
 
     /**
      * A combined editor and renderer for the {@link IField}s of a
      * {@link Record}. This delegates to an {@link IFieldUI} that will handle
      * the specific type of the field being rendered or edited.
      * 
      * @author Ramon Servadei
      */
     class RecordTableCellRendererAndEditor extends AbstractCellEditor implements
         TableCellRenderer, TableCellEditor
     {
         /** Default serial version UID */
         private static final long serialVersionUID = 1L;
 
         /**
          * The current active UI component, used mainly for the
          * {@link #getCellEditorValue()}
          */
         private IFieldUI activeUI;
 
         public RecordTableCellRendererAndEditor()
         {
             super();
         }
 
         @SuppressWarnings("boxing")
         public Component getTableCellRendererComponent(JTable table,
             Object value, boolean isSelected, boolean hasFocus, final int row,
             final int column)
         {
             final int convertedColumn = convertColumnIndexToModel(column);
             final Component renderer =
                 doGetComponent(table, value, isSelected, hasFocus, row,
                     convertedColumn, true);
 
             final Format format =
                 getModel().getFormats().get(row).get(convertedColumn);
             if (renderer instanceof JComponent)
             {
                 ((JComponent) renderer).setOpaque(format.isOpaque());
             }
 
             // determine if there is an update to the cell value
             final Iterator<Integer> iterator =
                 RecordTable.this.updateHandler.getUpdated().get(row).iterator();
             while (iterator.hasNext())
             {
                 final Integer next = iterator.next();
                 if (next.equals(convertedColumn))
                 {
                     iterator.remove();
                     format.setUpdate(true);
                     TableUpdateHandler.updateTimer.schedule(new TimerTask()
                     {
                         @Override
                         public void run()
                         {
                             SwingUtilities.invokeLater(new Runnable()
                             {
                                 public void run()
                                 {
                                     format.setUpdate(false);
                                     // trigger another render update
                                     getModel().fireTableCellUpdated(row,
                                         convertedColumn);
                                 }
                             });
                         }
                     }, 500);
                 }
             }
 
             renderer.setBackground(format.getBackground(isSelected));
             return renderer;
         }
 
         public Component getTableCellEditorComponent(JTable table,
             Object value, boolean isSelected, int row, int column)
         {
             return doGetComponent(table, value, isSelected, true, row,
                 convertColumnIndexToModel(column), false);
         }
 
         public Object getCellEditorValue()
         {
             return this.activeUI == null ? EMPTY_STRING
                 : this.activeUI.getCellEditorValue();
         }
 
         /**
          * Choke-point method to get the {@link AbstractFieldUI} for a given
          * cell in the table. This is used to return the renderer or editor.
          * 
          * @param table
          *            the table
          * @param value
          *            the value for the component
          * @param isSelected
          *            whether it is selected
          * @param hasFocus
          *            whether it has focus
          * @param row
          *            the row of the cell
          * @param column
          *            the column of the cell
          * @param renderer
          *            whether to return a renderer
          * @return a renderer or editor for the cell in the table
          */
         @SuppressWarnings("boxing")
         private Component doGetComponent(JTable table, Object value,
             boolean isSelected, boolean hasFocus, int row, int column,
             boolean renderer)
         {
             IType type = Type.STRING_FIELD;
             final Record record = getModel().getRecords().get(row);
             final Format format = getModel().getFormats().get(row).get(column);
             if (column >= Address.values().length)
             {
                 final String fieldName =
                     getModel().getFieldIndexes().get(column);
                 final IField field = record.get(fieldName);
                 // for a non existent field, use a 'blank' cell
                 if (field == null)
                 {
                     JLabel component = new JLabel();
                     component.setText("" + value);
                     format.setBackground(Color.gray);
                     format.setOpaque(true);
                     component.setEnabled(false);
                     return component;
                 }
                 type = field.getType();
             }
             // not fantastic, need a better place to set this 'once'
             format.setBackground(Color.white);
             // note: by default, the record name is shown as a string
             IFieldUI ui = getFieldUIForType(type);
             Component component;
             if (renderer)
             {
                 component =
                     ui.getTableCellRendererComponent(table, value, isSelected,
                         hasFocus, row, column);
             }
             else
             {
                 component =
                     ui.getTableCellEditorComponent(table, value, isSelected,
                         row, column);
             }
             this.activeUI = ui;
             if (DataState.STALE.equals(record.getDataState()))
             {
                 component.setEnabled(false);
             }
             else
             {
                 component.setEnabled(true);
             }
             return component;
         }
 
         /**
          * Helper that gets a {@link AbstractFieldUI} for the field type
          * 
          * @param fieldType
          *            the field type
          * @return the field UI object that handles rendering and editing for
          *         the field type
          */
         private IFieldUI getFieldUIForType(final IType fieldType)
         {
             return UIStore.get(fieldType);
         }
     }
 
     /**
      * Encapsulates the default event filter for all table instances. This
      * includes both listening to records and any state changes for the records.
      */
     static final Class<? extends IEvent>[] eventFilter =
         EventListenerUtils.createFilter(IContainer.class,
             ContainerStateChangeEvent.class, ContainerFieldRemovedEvent.class,
             ContainerFieldAddedEvent.class);
 
     /** The table model, also the delegate for the {@link IEventListener} */
     private final RecordTableModel model;
 
     /** Handles all the table update redraw logic */
     private final TableUpdateHandler updateHandler = new TableUpdateHandler();
 
     public RecordTable()
     {
         super();
         this.model = new RecordTableModel();
         setModel(this.model);
         setAutoCreateColumnsFromModel(true);
     }
 
     @Override
     public RecordTableModel getModel()
     {
         return this.model;
     }
 
     /**
      * Adds specific cell render and editors
      */
     @Override
     public void createDefaultColumnsFromModel()
     {
         super.createDefaultColumnsFromModel();
         final Enumeration<TableColumn> columns = getColumnModel().getColumns();
         while (columns.hasMoreElements())
         {
             final TableColumn column = columns.nextElement();
             final RecordTableCellRendererAndEditor cellRenderer =
                 new RecordTableCellRendererAndEditor();
             column.setCellRenderer(cellRenderer);
             column.setCellEditor(cellRenderer);
         }
     }
 
     /**
      * A cell is only editable if the record backing the cell has a field for
      * this.
      */
     public boolean isCellEditable(int row, int col)
     {
         final Record record = getModel().getRecords().get(row);
         col = convertColumnIndexToModel(col);
         final String fieldName = getModel().getFieldIndexes().get(col);
         return record.contains(fieldName);
     }
 
     public void setValueAt(final Object value, int row, int col)
     {
         if (LOG.isTraceEnabled())
         {
             LOG.trace("value=" + value + ", row=" + row + ", col=" + col);
         }
         Record record = getModel().getRecords().get(row);
         col = convertColumnIndexToModel(col);
         final String fieldName = getModel().getFieldIndexes().get(col);
         if (record.isLocal())
         {
             // get the actual record (the table model only has the clones)
             record =
                 (Record) record.getContext().getLocalContainer(
                     record.getIdentity(), record.getType(), record.getDomain());
             record.beginFrame(new EventFrameExecution());
             try
             {
                 final IField field = record.get(fieldName);
                 if (field == null)
                 {
                     if (LOG.isTraceEnabled())
                     {
                         LOG.trace("No field");
                     }
                     return;
                 }
                 try
                 {
                     field.setValueFromString(EMPTY_STRING + value);
                 }
                 catch (Exception e)
                 {
                     Utils.logException(LOG, "Could not set " + value + " on "
                         + field + " for record " + record.getAddress(), e);
                 }
             }
             finally
             {
                 record.endFrame();
             }
         }
         else
         {
             final IContainer remoteRecord = record;
             // spin off onto a thread - should really use an executor
             record.getContext().execute(new Runnable()
             {
                 public void run()
                 {
                     remoteRecord.getContext().updateRemoteContainer(
                         remoteRecord.getNativeContextIdentity(),
                         remoteRecord.getIdentity(), remoteRecord.getType(),
                         remoteRecord.getDomain(), fieldName,
                         EMPTY_STRING + value);
                 }
             });
         }
     }
 
     public void addedAsListenerFor(IEventSource source)
     {
         getModel().addedAsListenerFor(source);
     }
 
     public Class<? extends IEvent>[] getEventTypeFilter()
     {
         return getModel().getEventTypeFilter();
     }
 
     public void removedAsListenerFrom(IEventSource source)
     {
         getModel().removedAsListenerFrom(source);
     }
 
     public void update(IEvent event)
     {
         getModel().update(event);
     }
 
     /**
      * @return the selected {@link Record}. Note: this is a clone, not the
      *         original in the {@link IFulmineContext}
      */
     public Record getSelectedRecord()
     {
         return getModel().getRecords().get(getSelectedRow());
     }
 
     /**
      * @return the selected {@link IField}.
      */
     public IField getSelectedField()
     {
         final int column = convertColumnIndexToModel(getSelectedColumn());
         final String name = getModel().getColumnName(column);
         final Record record = getSelectedRecord();
         return record.get(name);
     }
 }
 
 /**
  * Encapsulates re-usable logic for determining updated cells in a table.
  * 
  * @author Ramon Servadei
  */
 final class TableUpdateHandler
 {
 
     /** Handles clearing any update flashes */
     final static Timer updateTimer;
     static
     {
         updateTimer =
             new Timer(TableUpdateHandler.class.getSimpleName() + "UpdateTimer",
                 true);
     }
 
     /**
      * Tracks cells that have updated (row, col).
      */
     private final IAutoCreatingStore<Integer, Set<Integer>> updated =
         new AutoCreatingStore<Integer, Set<Integer>>(
             new IObjectBuilder<Integer, Set<Integer>>()
             {
                 public Set<Integer> create(Integer key)
                 {
                     return CollectionFactory.newSet(1);
                 }
             });
 
     /**
      * @return the cells that have updated, accessed via (row, col). If the cell
      *         is not in the returned construct, it has not updated.
      */
     IAutoCreatingStore<Integer, Set<Integer>> getUpdated()
     {
         return this.updated;
     }
 
 }