package com.webobjects.appserver;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.ObjectStreamField;
import java.io.Serializable;
import java.lang.reflect.Array;
import java.util.Enumeration;
import com.webobjects.eocontrol.EOAndQualifier;
import com.webobjects.eocontrol.EOArrayDataSource;
import com.webobjects.eocontrol.EOClassDescription;
import com.webobjects.eocontrol.EODataSource;
import com.webobjects.eocontrol.EODelayedObserverQueue;
import com.webobjects.eocontrol.EODetailDataSource;
import com.webobjects.eocontrol.EOEditingContext;
import com.webobjects.eocontrol.EOKeyValueArchiver;
import com.webobjects.eocontrol.EOKeyValueArchiving;
import com.webobjects.eocontrol.EOKeyValueQualifier;
import com.webobjects.eocontrol.EOKeyValueUnarchiver;
import com.webobjects.eocontrol.EOObjectStore;
import com.webobjects.eocontrol.EOObserverCenter;
import com.webobjects.eocontrol.EOObserverProxy;
import com.webobjects.eocontrol.EOQualifier;
import com.webobjects.eocontrol.EOSortOrdering;
import com.webobjects.eocontrol._EOFlatMutableDictionary;
import com.webobjects.eocontrol._EOMutableDefaultValueDictionary;
import com.webobjects.foundation.NSArray;
import com.webobjects.foundation.NSCoder;
import com.webobjects.foundation.NSComparator;
import com.webobjects.foundation.NSDictionary;
import com.webobjects.foundation.NSDisposable;
import com.webobjects.foundation.NSForwardException;
import com.webobjects.foundation.NSKeyValueCoding;
import com.webobjects.foundation.NSKeyValueCodingAdditions;
import com.webobjects.foundation.NSLog;
import com.webobjects.foundation.NSMutableArray;
import com.webobjects.foundation.NSMutableDictionary;
import com.webobjects.foundation.NSMutableSet;
import com.webobjects.foundation.NSNotification;
import com.webobjects.foundation.NSNotificationCenter;
import com.webobjects.foundation.NSSelector;
import com.webobjects.foundation.NSUndoManager;
import com.webobjects.foundation.NSValidation;
import com.webobjects.foundation._NSArrayUtilities;
import com.webobjects.foundation._NSDelegate;
import com.webobjects.foundation._NSUtilities;
/**
* Reimplemented to fix NullPointerExceptions in deserialization.
*
*/
public class WODisplayGroup implements NSKeyValueCoding, NSKeyValueCoding.ErrorHandling, NSDisposable,
EOKeyValueArchiving, EOKeyValueArchiving.Awaking, Serializable {
/**
* Do I need to update serialVersionUID? See section 5.6 <cite>Type Changes
* Affecting Serialization</cite> on page 51 of the <a
* href="http://java.sun.com/j2se/1.4/pdf/serial-spec.pdf">Java Object
* Serialization Spec</a>
*/
private static final long serialVersionUID = 1L;
private static final NSSelector<Void> SetQualifier = new NSSelector<Void>("setQualifier",
new Class[] { EOQualifier.class });
private static final NSSelector<Void> SetAuxiliaryQualifier = new NSSelector<Void>("setAuxiliaryQualifier",
new Class[] { EOQualifier.class });
private static final NSSelector<Void> SetQualifierBindings = new NSSelector<Void>("setQualifierBindings",
new Class[] { NSDictionary.class });
private static NSSelector<Boolean> _selectObjects = new NSSelector<Boolean>("selectObjectsIdenticalTo",
new Class[] { NSArray.class });
private static NSSelector<Void> _insertObject = new NSSelector<Void>("_insertObjectAtIndex",
new Class[] { Object.class });
private static NSSelector<Boolean> _deleteObject = new NSSelector<Boolean>("_deleteObject",
new Class[] { Object.class });
private static final String shouldRefetch = "displayGroupShouldRefetchForInvalidatedAllObjects";
private static final String shouldChangeSelection = "displayGroupShouldChangeSelectionToIndexes";
private static final String didChangeSelectedObjects = "displayGroupDidChangeSelectedObjects";
private static final String didChangeSelection = "displayGroupDidChangeSelection";
private static final String shouldFetch = "displayGroupShouldFetch";
private static final String didFetch = "displayGroupDidFetchObjects";
private static final String displayArray = "displayGroupDisplayArrayForObjects";
private static final String createObjectFailed = "displayGroupCreateObjectFailedForDataSource";
private static final String shouldInsertObject = "displayGroupShouldInsertObject";
private static final String didInsertObject = "displayGroupDidInsertObject";
private static final String shouldDeleteObject = "displayGroupShouldDeleteObject";
private static final String didDeleteObject = "displayGroupDidDeleteObject";
private static final String didChangeDataSource = "displayGroupDidChangeDataSource";
private static final String DataSourceFieldKey = "dataSource";
private static final String DelegateFieldKey = "delegate";
private static final String SortOrderingFieldKey = "sortOrdering";
private static final String QualifierFieldKey = "qualifier";
private static final String FlagsFieldKey = "flags";
private static final String NumberObjectsPerBatchFieldKey = "numObjectsPerBatch";
private static final String BatchIndexFieldKey = "batchIndex";
private static final String LocalKeysFieldKey = "localKeys";
private static final String AllObjectsFieldKey = "allObjects";
private static final String DisplayedObjectsFieldKey = "displayedObjects";
private static final String SelectionFieldKey = "selection";
private static final ObjectStreamField[] serialPersistentFields = {
new ObjectStreamField(DataSourceFieldKey, EODataSource.class),
new ObjectStreamField(DelegateFieldKey, _NSDelegate.class),
new ObjectStreamField(SortOrderingFieldKey, NSArray.class),
new ObjectStreamField(QualifierFieldKey, EOQualifier.class),
new ObjectStreamField(FlagsFieldKey, boolean[].class),
new ObjectStreamField(NumberObjectsPerBatchFieldKey, Integer.TYPE),
new ObjectStreamField(BatchIndexFieldKey, Integer.TYPE),
new ObjectStreamField(LocalKeysFieldKey, NSArray.class),
new ObjectStreamField(AllObjectsFieldKey, NSMutableArray.class),
new ObjectStreamField(DisplayedObjectsFieldKey, NSMutableArray.class),
new ObjectStreamField(SelectionFieldKey, NSArray.class) };
private EODataSource _dataSource;
private transient boolean _customDataSourceClass;
private NSMutableArray _allObjects;
private NSMutableArray _displayedObjects;
private _NSDelegate _delegate;
private NSArray _selection;
private NSArray<EOSortOrdering> _sortOrdering;
private EOQualifier _qualifier;
private NSArray<String> _localKeys;
private transient NSMutableArray _selectedObjects;
private transient EOObserverProxy _observerNotificationBeginProxy;
private transient EOObserverProxy _observerNotificationEndProxy;
private transient int _updatedObjectIndex;
private transient NSDictionary _insertedObjectDefaultValues;
private transient NSMutableArray _savedAllObjects;
private transient _EOFlatMutableDictionary _queryMatch;
private transient _EOFlatMutableDictionary _queryMin;
private transient _EOFlatMutableDictionary _queryMax;
private transient _EOMutableDefaultValueDictionary _queryOperator;
private transient String _defaultStringMatchOperator;
private transient char[] _defaultStringMatchFormat;
private transient int _DSMFindexOfObject;
private transient NSMutableDictionary _queryBindings;
private boolean _flags_selectsFirstObjectAfterFetch;
private boolean _flags_autoFetch;
private transient boolean _flags_haveFetched;
private boolean _flags_validateImmediately;
private boolean _flags_queryMode;
private transient boolean _flags_initialized;
private transient boolean _wasDisposed = false;
int _numberOfObjectsPerBatch;
int _batchIndex = 1;
private static NSArray _stringQualifierOperators;
private static NSArray _allQualifierOperators;
private static final String QUERYOPERATOR_DEFAULTSTRING = "";
private static final char QUERYOPERATOR_WILDCARD = '*';
private static final String QUERYMATCH_DEFAULTSTRING = "%@*";
private static String _globalDefaultStringMatchFormat = QUERYMATCH_DEFAULTSTRING;
private static String _globalDefaultStringMatchOperator = "caseInsensitiveLike";
private static boolean _globalDefaultForValidatesChangesImmediately = false;
public static final String DisplayGroupWillFetchNotification = "WODisplayGroupWillFetch";
public static String globalDefaultStringMatchOperator() {
return _globalDefaultStringMatchOperator;
}
public static void setGlobalDefaultStringMatchOperator(String op) {
_globalDefaultStringMatchOperator = op;
}
public static String globalDefaultStringMatchFormat() {
return _globalDefaultStringMatchFormat;
}
public static void setGlobalDefaultStringMatchFormat(String format) {
_globalDefaultStringMatchFormat = format;
}
public static boolean globalDefaultForValidatesChangesImmediately() {
return _globalDefaultForValidatesChangesImmediately;
}
public static void setGlobalDefaultForValidatesChangesImmediately(boolean yn) {
_globalDefaultForValidatesChangesImmediately = yn;
}
private void _init(boolean forSerialization) {
if (!forSerialization) {
_selection = NSArray.EmptyArray;
_allObjects = new NSMutableArray();
_displayedObjects = new NSMutableArray();
_delegate = new _NSDelegate(Delegate.class);
_numberOfObjectsPerBatch = 0;
setCurrentBatchIndex(1);
}
_queryMatch = new _EOFlatMutableDictionary();
_queryMax = new _EOFlatMutableDictionary();
_queryMin = new _EOFlatMutableDictionary();
_queryOperator = new _EOMutableDefaultValueDictionary();
_queryOperator.setDefaultValue(QUERYOPERATOR_DEFAULTSTRING);
_queryBindings = new NSMutableDictionary();
_insertedObjectDefaultValues = NSDictionary.EmptyDictionary;
setDefaultStringMatchFormat(_globalDefaultStringMatchFormat);
_defaultStringMatchOperator = _globalDefaultStringMatchOperator;
setSelectsFirstObjectAfterFetch(true);
}
private boolean _isCustomDataSourceClass(Class c) {
return (c != EODetailDataSource.class) && (c != EOArrayDataSource.class);
}
private void _setUpForNewDataSource() {
if (_dataSource != null) {
_customDataSourceClass = _isCustomDataSourceClass(_dataSource.getClass());
EOEditingContext editingContext = _dataSource.editingContext();
if (editingContext != null) {
NSNotificationCenter.defaultCenter().addObserver(this,
new NSSelector<Void>("objectsChangedInEditingContext", new Class[] { NSNotification._CLASS }),
EOEditingContext.ObjectsChangedInEditingContextNotification, editingContext);
NSNotificationCenter.defaultCenter().addObserver(
this,
new NSSelector<Void>("objectsInvalidatedInEditingContext",
new Class[] { NSNotification._CLASS }),
EOObjectStore.InvalidatedAllObjectsInStoreNotification, editingContext);
}
}
}
protected void finishInitialization() {
if (_flags_initialized) {
return;
}
_setUpForNewDataSource();
_flags_initialized = true;
}
public WODisplayGroup() {
_init(false);
finishInitialization();
}
public void dispose() {
if (!_wasDisposed) {
_delegate = null;
NSNotificationCenter.defaultCenter().removeObserver(this);
EOObserverCenter.removeObserver(_observerNotificationBeginProxy, this);
EODelayedObserverQueue.defaultObserverQueue().dequeueObserver(_observerNotificationBeginProxy);
_observerNotificationBeginProxy = null;
EOObserverCenter.removeObserver(_observerNotificationEndProxy, this);
EODelayedObserverQueue.defaultObserverQueue().dequeueObserver(_observerNotificationEndProxy);
_observerNotificationEndProxy = null;
if (undoManager() != null)
undoManager().removeAllActionsWithTarget(this);
setDataSource(null);
_selection = null;
_selectedObjects = null;
_sortOrdering = null;
_allObjects = null;
_displayedObjects = null;
_insertedObjectDefaultValues = null;
_queryMin = null;
_queryMax = null;
_queryMatch = null;
_queryOperator = null;
_queryBindings = null;
_savedAllObjects = null;
_defaultStringMatchOperator = null;
_defaultStringMatchFormat = null;
_localKeys = null;
}
_wasDisposed = true;
}
public Object initWithCoder(NSCoder coder) {
_init(true);
setDataSource((EODataSource) coder.decodeObject());
setDelegate(coder.decodeObject());
setSortOrderings((NSArray) coder.decodeObject());
setQualifier((EOQualifier) coder.decodeObject());
_flags_autoFetch = coder.decodeBoolean();
_flags_validateImmediately = coder.decodeBoolean();
_flags_selectsFirstObjectAfterFetch = coder.decodeBoolean();
_flags_queryMode = coder.decodeBoolean();
_numberOfObjectsPerBatch = coder.decodeInt();
setCurrentBatchIndex(coder.decodeInt());
setLocalKeys((NSArray) coder.decodeObject());
_allObjects = null;
_displayedObjects = null;
_selection = null;
_selectedObjects = null;
_allObjects = ((NSMutableArray) coder.decodeObject());
_displayedObjects = ((NSMutableArray) coder.decodeObject());
_selection = ((NSArray) coder.decodeObject());
return this;
}
private void writeObject(ObjectOutputStream out) throws IOException {
ObjectOutputStream.PutField fields = out.putFields();
fields.put(DataSourceFieldKey, _dataSource);
fields.put(DelegateFieldKey, _delegate);
fields.put(SortOrderingFieldKey, _sortOrdering);
fields.put(QualifierFieldKey, _qualifier);
boolean[] flags = { _flags_autoFetch, _flags_validateImmediately, _flags_selectsFirstObjectAfterFetch,
_flags_queryMode };
fields.put(FlagsFieldKey, flags);
fields.put(NumberObjectsPerBatchFieldKey, _numberOfObjectsPerBatch);
fields.put(LocalKeysFieldKey, _localKeys);
fields.put(AllObjectsFieldKey, _allObjects);
fields.put(DisplayedObjectsFieldKey, _displayedObjects);
/*
* Read/Set batchIndex AFTER displayed objects as setting batch index
* tries to read displayed objects for count
*/
fields.put(BatchIndexFieldKey, currentBatchIndex());
fields.put(SelectionFieldKey, _selection);
out.writeFields();
}
private void readObject(ObjectInputStream in) throws IOException, ClassNotFoundException {
_init(true);
ObjectInputStream.GetField fields = in.readFields();
_dataSource = ((EODataSource) fields.get(DataSourceFieldKey, null));
_delegate = ((_NSDelegate) fields.get(DelegateFieldKey, null));
_sortOrdering = ((NSArray) fields.get(SortOrderingFieldKey, null));
_qualifier = ((EOQualifier) fields.get(QualifierFieldKey, null));
boolean[] flags = (boolean[]) fields.get(FlagsFieldKey, null);
if (flags != null) {
int i = 0;
_flags_autoFetch = flags[(i++)];
_flags_validateImmediately = flags[(i++)];
_flags_selectsFirstObjectAfterFetch = flags[(i++)];
_flags_queryMode = flags[(i++)];
}
_numberOfObjectsPerBatch = fields.get(NumberObjectsPerBatchFieldKey, 0);
_localKeys = ((NSArray<String>) fields.get(LocalKeysFieldKey, null));
_allObjects = ((NSMutableArray) fields.get(AllObjectsFieldKey, null));
_displayedObjects = ((NSMutableArray) fields.get(DisplayedObjectsFieldKey, null));
/*
* Read/Set batchIndex AFTER displayed objects as setting batch index
* tries to read displayed objects for count
*/
setCurrentBatchIndex(fields.get(BatchIndexFieldKey, 1));
_selection = ((NSArray) fields.get(SelectionFieldKey, null));
finishInitialization();
}
public void encodeWithCoder(NSCoder coder) {
coder.encodeObject(_dataSource);
coder.encodeObject(_delegate);
coder.encodeObject(_sortOrdering);
coder.encodeObject(_qualifier);
coder.encodeBoolean(_flags_autoFetch);
coder.encodeBoolean(_flags_validateImmediately);
coder.encodeBoolean(_flags_selectsFirstObjectAfterFetch);
coder.encodeBoolean(_flags_queryMode);
coder.encodeInt(_numberOfObjectsPerBatch);
coder.encodeInt(currentBatchIndex());
coder.encodeObject(localKeys());
coder.encodeObject(_allObjects);
coder.encodeObject(_displayedObjects);
coder.encodeObject(_selection);
}
public boolean selectsFirstObjectAfterFetch() {
return _flags_selectsFirstObjectAfterFetch;
}
public void setSelectsFirstObjectAfterFetch(boolean yn) {
_flags_selectsFirstObjectAfterFetch = yn;
}
public void setValidatesChangesImmediately(boolean yn) {
_flags_validateImmediately = yn;
}
public boolean validatesChangesImmediately() {
return _flags_validateImmediately;
}
public void setFetchesOnLoad(boolean yn) {
_flags_autoFetch = yn;
}
public boolean fetchesOnLoad() {
return _flags_autoFetch;
}
public NSArray allObjects() {
return _allObjects;
}
public NSArray displayedObjects() {
if (_numberOfObjectsPerBatch == 0) {
return _displayedObjects;
}
NSMutableArray objectsOfCurrentBatch = new NSMutableArray(_numberOfObjectsPerBatch);
int e = 0;
int numberOfRecords = _displayedObjects.count();
int currentBatchIndex = currentBatchIndex();
if (numberOfRecords > currentBatchIndex * _numberOfObjectsPerBatch) {
numberOfRecords = currentBatchIndex * _numberOfObjectsPerBatch;
}
for (int i = (currentBatchIndex - 1) * _numberOfObjectsPerBatch; i < numberOfRecords; i++) {
objectsOfCurrentBatch.insertObjectAtIndex(_displayedObjects.objectAtIndex(i), e++);
}
return objectsOfCurrentBatch;
}
public void setQualifier(EOQualifier qualifier) {
_qualifier = qualifier;
}
public EOQualifier qualifier() {
return _qualifier;
}
public void setSortOrderings(NSArray<EOSortOrdering> keySortOrderArray) {
_sortOrdering = keySortOrderArray;
}
public NSArray<EOSortOrdering> sortOrderings() {
return _sortOrdering;
}
public void updateDisplayedObjects() {
NSMutableArray oldObjectSelection = (NSMutableArray) selectedObjects();
NSArray newDisplayArray = _allObjects;
if (_delegate.respondsTo(displayArray)) {
newDisplayArray = (NSArray) _delegate.perform(displayArray, this, newDisplayArray);
} else {
if (_qualifier != null) {
newDisplayArray = EOQualifier.filteredArrayWithQualifier(newDisplayArray, _qualifier);
}
if (_sortOrdering != null) {
newDisplayArray = EOSortOrdering.sortedArrayUsingKeyOrderArray(newDisplayArray, _sortOrdering);
}
}
_displayedObjects = new NSMutableArray(newDisplayArray);
selectObjectsIdenticalToSelectFirstOnNoMatch(oldObjectSelection, false);
redisplay();
}
public void setObjectArray(NSArray array) {
NSMutableArray oldObjectSelection = (NSMutableArray) selectedObjects();
_allObjects = (array != null ? new NSMutableArray(array) : new NSMutableArray());
updateDisplayedObjects();
selectObjectsIdenticalToSelectFirstOnNoMatch(oldObjectSelection, selectsFirstObjectAfterFetch());
redisplay();
}
public void setDataSource(EODataSource ds) {
if (_dataSource == ds) {
return;
}
if (_dataSource != null) {
EOEditingContext editingContext = _dataSource.editingContext();
if (editingContext != null) {
editingContext.removeEditor(this);
if (editingContext.messageHandler() == this) {
editingContext.setMessageHandler(null);
}
}
}
_dataSource = ds;
_setUpForNewDataSource();
setObjectArray(null);
_notifyWith(didChangeDataSource, this);
}
public EODataSource dataSource() {
return _dataSource;
}
public void setDelegate(Object anObject) {
_delegate.setDelegate(anObject);
}
public Object delegate() {
return _delegate.delegate();
}
public NSArray<String> localKeys() {
if (_localKeys == null) {
_localKeys = NSArray.emptyArray();
}
return _localKeys;
}
public void setLocalKeys(NSArray<String> newKeySet) {
_localKeys = newKeySet;
}
public void objectsChangedInEditingContext(NSNotification notification) {
boolean should = true;
NSArray deletedObjects = (NSArray) notification.userInfo().objectForKey("deleted");
int deletedCount = deletedObjects != null ? deletedObjects.count() : 0;
if ((deletedObjects != null) && (deletedCount != 0)) {
NSMutableSet allHash = new NSMutableSet(_allObjects);
NSMutableSet displayedHash = null;
NSMutableSet selectedHash = null;
boolean rebuildAll = false;
boolean rebuildDisplayed = false;
boolean rebuildSelected = false;
for (int i = 0; i < deletedCount; i++) {
Object deletedObject = deletedObjects.objectAtIndex(i);
if (allHash.containsObject(deletedObject)) {
allHash.removeObject(deletedObject);
rebuildAll = true;
if (displayedHash == null) {
displayedHash = new NSMutableSet(_displayedObjects);
}
if (displayedHash.containsObject(deletedObject)) {
displayedHash.removeObject(deletedObject);
rebuildDisplayed = true;
if (selectedHash == null) {
/*
* Updated to use lazy loading accessor method since
* _selectedObjects is null after deserialization,
* resulting in a NullPointerException in the
* NSMutableSet constructor
*/
selectedHash = new NSMutableSet(selectedObjects());
}
if (selectedHash.containsObject(deletedObject)) {
selectedHash.removeObject(deletedObject);
rebuildSelected = true;
}
}
}
}
if (rebuildAll) {
_allObjects = new NSMutableArray(allHash.allObjects());
if (rebuildDisplayed) {
for (int i = _displayedObjects.count() - 1; i >= 0; i--) {
Object displayedObject = _displayedObjects.objectAtIndex(i);
if ((displayedHash == null) || (!displayedHash.containsObject(displayedObject))) {
_displayedObjects.removeObjectAtIndex(i);
}
}
if ((selectedHash != null) && (rebuildSelected)) {
_selectedObjects = new NSMutableArray(selectedHash.allObjects());
}
_selection = _NSArrayUtilities.indexesForObjectsIndenticalTo(_displayedObjects, _selectedObjects);
}
}
}
if ((should) || (deletedCount != 0))
redisplay();
}
public void objectsInvalidatedInEditingContext(NSNotification notification) {
boolean should = true;
if (_delegate.respondsTo(shouldRefetch)) {
should = _delegate.booleanPerform(shouldRefetch, this, notification);
}
if (should) {
fetch();
}
}
public NSUndoManager undoManager() {
return (_dataSource != null) && (_dataSource.editingContext() != null) ? _dataSource.editingContext()
.undoManager() : null;
}
private Object _notifyWith(String sel, Object arg) {
if ((_delegate != null) && (_delegate.respondsTo(sel))) {
_delegate.perform(sel, arg);
}
return this;
}
private Object _notifyWithWith(String sel, Object arg1, Object arg2) {
if ((_delegate != null) && (_delegate.respondsTo(sel))) {
_delegate.perform(sel, arg1, arg2);
}
return this;
}
private void _notifyRowChanged(int index) {
if (_updatedObjectIndex != index) {
_updatedObjectIndex = (_updatedObjectIndex == -2 ? index : -1);
}
willChange();
}
private void _notifySelectionChanged() {
if (_delegate.respondsTo(didChangeSelection)) {
_delegate.perform(didChangeSelection, this);
}
willChange();
}
public void _beginObserverNotification(Object sender) {
if ((!_flags_haveFetched) && (_flags_autoFetch))
fetch();
}
public void _lastObserverNotified(Object sender) {
_updatedObjectIndex = -2;
EOObserverCenter.notifyObserversObjectWillChange(null);
}
private int _selectionIndex() {
if (_selection.count() != 0) {
return ((Integer) _selection.objectAtIndex(0)).intValue();
}
return -1;
}
public NSArray selectionIndexes() {
return _selection;
}
public NSArray selectedObjects() {
if (_selectedObjects == null) {
_selectedObjects = ((NSMutableArray) _NSArrayUtilities.objectsAtIndexes(_displayedObjects, _selection));
}
return _selectedObjects;
}
public void setSelectedObjects(NSArray objects) {
_selectedObjects = new NSMutableArray(objects);
_selection = _NSArrayUtilities.indexesForObjectsIndenticalTo(_displayedObjects, _selectedObjects);
}
public Object selectedObject() {
NSArray selectedObjects = selectedObjects();
if (selectedObjects.count() != 0) {
return selectedObjects.objectAtIndex(0);
}
return null;
}
public void setSelectedObject(Object anObject) {
if (anObject != null)
setSelectedObjects(new NSArray(anObject));
else
clearSelection();
}
@Deprecated
public boolean endEditing() {
return true;
}
public boolean setSelectionIndexes(NSArray s) {
NSArray sortedArray = null;
if (s.count() > 1)
try {
sortedArray = s.sortedArrayUsingComparator(NSComparator.AscendingNumberComparator);
} catch (NSComparator.ComparisonException exception) {
throw NSForwardException._runtimeExceptionForThrowable(exception);
}
else if (_displayedObjects.count() < 1)
sortedArray = NSArray.EmptyArray;
else {
sortedArray = new NSArray(s);
}
NSMutableArray newSelectedObjects = (NSMutableArray) _NSArrayUtilities.objectsAtIndexes(_displayedObjects,
sortedArray);
boolean selectedObjectsChanged = !newSelectedObjects.equals(selectedObjects());
boolean selectionIndexesChanged = !sortedArray.equals(_selection);
if ((!selectedObjectsChanged) && (!selectionIndexesChanged)) {
return true;
}
if (!endEditing()) {
return false;
}
if ((_delegate.respondsTo(shouldChangeSelection))
&& (!_delegate.booleanPerform(shouldChangeSelection, this, s))) {
return false;
}
if (selectionIndexesChanged) {
_selection = sortedArray;
}
if (selectedObjectsChanged) {
_selectedObjects = newSelectedObjects;
}
if ((selectedObjectsChanged) && (_delegate.respondsTo(didChangeSelectedObjects))) {
_delegate.perform(didChangeSelectedObjects, this);
}
if ((selectedObjectsChanged) || (selectionIndexesChanged)) {
_notifySelectionChanged();
}
return true;
}
public boolean selectObject(Object object) {
return selectObjectsIdenticalTo(new NSArray(object));
}
public boolean selectObjectsIdenticalTo(NSArray objectSelection) {
NSArray newSelection = _NSArrayUtilities.indexesForObjectsIndenticalTo(_displayedObjects, objectSelection);
boolean s = setSelectionIndexes(newSelection);
if ((objectSelection.count() > 0) && (newSelection.count() == 0)) {
return false;
}
return s;
}
public boolean selectObjectsIdenticalToSelectFirstOnNoMatch(NSArray objectSelection, boolean selectFirstOnNoMatch) {
NSArray newSelection = _NSArrayUtilities.indexesForObjectsIndenticalTo(_displayedObjects, objectSelection);
if (newSelection.count() == 0) {
if ((selectFirstOnNoMatch) && (_displayedObjects.count() != 0)) {
newSelection = new NSArray(Integer.valueOf(0));
} else {
newSelection = _NSArrayUtilities.closestMatchingIndexes(_selection, _displayedObjects.count(),
selectFirstOnNoMatch);
}
}
return setSelectionIndexes(newSelection);
}
public Object selectNext() {
if (_displayedObjects.count() == 0)
return null;
Integer newIndex;
if (_selection.count() == 0) {
newIndex = _NSUtilities.IntegerForInt(0);
} else {
Integer firstIndex = (Integer) _selection.objectAtIndex(0);
if (firstIndex.intValue() == _displayedObjects.count() - 1)
newIndex = _NSUtilities.IntegerForInt(0);
else {
newIndex = _NSUtilities.IntegerForInt(firstIndex.intValue() + 1);
}
}
NSArray newSelection = new NSArray(newIndex);
setSelectionIndexes(newSelection);
return null;
}
public Object selectPrevious() {
if (_displayedObjects.count() == 0)
return null;
Integer newIndex;
if (_selection.count() == 0) {
newIndex = _NSUtilities.IntegerForInt(0);
} else {
Integer firstIndex = (Integer) _selection.objectAtIndex(0);
if (firstIndex.intValue() == 0)
newIndex = _NSUtilities.IntegerForInt(_displayedObjects.count() - 1);
else {
newIndex = _NSUtilities.IntegerForInt(firstIndex.intValue() - 1);
}
}
NSArray newSelection = new NSArray(newIndex);
setSelectionIndexes(newSelection);
return null;
}
public boolean clearSelection() {
return setSelectionIndexes(NSArray.EmptyArray);
}
@Deprecated
public void redisplay() {
_notifyRowChanged(-1);
}
public boolean _deleteObject(Object anObject) {
if ((_delegate != null) && (_delegate.respondsTo(shouldDeleteObject))
&& (!_delegate.booleanPerform(shouldDeleteObject, this, anObject))) {
return false;
}
try {
if (_dataSource != null)
_dataSource.deleteObject(anObject);
} catch (Throwable localException) {
NSLog._conditionallyLogPrivateException(localException);
_presentAlertWithTitleMessage("Error Deleting Object", localException.toString());
return false;
}
if (undoManager() != null) {
undoManager().registerUndoWithTarget(this, _selectObjects, selectedObjects());
undoManager().registerUndoWithTarget(
this,
_insertObject,
new Object[] { anObject,
_NSUtilities.IntegerForInt(_displayedObjects.indexOfIdenticalObject(anObject)) });
}
_displayedObjects.removeIdenticalObject(anObject);
_allObjects.removeIdenticalObject(anObject);
selectObjectsIdenticalToSelectFirstOnNoMatch(selectedObjects(), false);
_notifyWithWith(didDeleteObject, this, anObject);
redisplay();
return true;
}
private boolean _deleteObjectsAtIndexes(NSArray indexes) {
int count = indexes.count();
NSMutableArray objects = new NSMutableArray(count);
for (int i = 0; i < count; i++) {
objects.addObject(_displayedObjects.objectAtIndex(((Integer) indexes.objectAtIndex(i)).intValue()));
}
boolean delectionSucceeded = true;
for (int i = 0; i < count; i++) {
if (!_deleteObject(objects.objectAtIndex(i))) {
delectionSucceeded = false;
}
}
return delectionSucceeded;
}
public boolean deleteSelection() {
endEditing();
return _deleteObjectsAtIndexes(selectionIndexes());
}
public boolean deleteObjectAtIndex(int anIndex) {
endEditing();
return _deleteObject(_allObjects.objectAtIndex(anIndex));
}
public void setInsertedObjectDefaultValues(NSDictionary defaultValues) {
if (defaultValues == null) {
throw new IllegalArgumentException(
"The inserted object default values dictionary on a WODisplayGroup may not be set to NULL. Try NSDictionary.EmptyDictionary instead.");
}
_insertedObjectDefaultValues = defaultValues;
}
public NSDictionary insertedObjectDefaultValues() {
return _insertedObjectDefaultValues;
}
public void _insertObjectAtIndex(Object args) {
Object object = Array.get(args, 0);
int index = ((Integer) Array.get(args, 1)).intValue();
insertObjectAtIndex(object, index);
}
public void insertObjectAtIndex(Object createObject, int newIndex) {
if (!endEditing()) {
return;
}
if (newIndex > _displayedObjects.count()) {
throw new IllegalArgumentException("WODisplayGroup::insertObjectAtIndex() " + newIndex
+ " beyond the bounds of " + _displayedObjects.count());
}
if ((_delegate.respondsTo(shouldInsertObject))
&& (!_delegate.booleanPerform(shouldInsertObject, this, createObject,
_NSUtilities.IntegerForInt(newIndex)))) {
return;
}
try {
if (_dataSource != null)
_dataSource.insertObject(createObject);
} catch (Throwable localException) {
NSLog._conditionallyLogPrivateException(localException);
_presentAlertWithTitleMessage("Error Inserting Object", localException.toString());
return;
}
if (undoManager() != null) {
try {
undoManager().registerUndoWithTarget(this, _selectObjects, selectedObjects());
undoManager().registerUndoWithTarget(this, _deleteObject, createObject);
} catch (Exception e) {
throw NSForwardException._runtimeExceptionForThrowable(e);
}
}
_displayedObjects.insertObjectAtIndex(createObject, newIndex);
_allObjects.insertObjectAtIndex(createObject, newIndex);
redisplay();
_notifyWithWith(didInsertObject, this, createObject);
selectObjectsIdenticalTo(new NSArray(createObject));
}
public Object insertNewObjectAtIndex(int newIndex) {
if (!endEditing()) {
return null;
}
Object createObject = _dataSource != null ? _dataSource.createObject() : null;
if (createObject == null) {
if (_delegate.respondsTo(createObjectFailed))
_delegate.perform(createObjectFailed, this, _dataSource);
else {
_presentAlertWithTitleMessage("", "Data source unable to provide new object.");
}
return null;
}
NSArray keysWithDefaultValue = _insertedObjectDefaultValues.allKeys();
int count = keysWithDefaultValue.count();
while (count-- > 0) {
String key = (String) keysWithDefaultValue.objectAtIndex(count);
NSKeyValueCodingAdditions.Utility.takeValueForKeyPath(createObject,
_insertedObjectDefaultValues.valueForKey(key), key);
}
insertObjectAtIndex(createObject, newIndex);
return createObject;
}
public Object fetch() {
_flags_haveFetched = true;
if (_dataSource == null) {
return null;
}
if (!endEditing()) {
return null;
}
if ((_delegate.respondsTo(shouldFetch)) && (!_delegate.booleanPerform(shouldFetch, this))) {
return null;
}
NSNotificationCenter.defaultCenter().postNotification("WODisplayGroupWillFetch", this);
if (undoManager() != null) {
undoManager().removeAllActionsWithTarget(this);
}
if ((_customDataSourceClass) && (SetQualifierBindings.implementedByObject(_dataSource))) {
try {
SetQualifierBindings.invoke(_dataSource, _queryBindings);
} catch (Exception e) {
throw NSForwardException._runtimeExceptionForThrowable(e);
}
}
NSArray anArray = _dataSource.fetchObjects();
setObjectArray(anArray);
_notifyWithWith(didFetch, this, _allObjects);
return null;
}
private EOQualifier _qualifierForKeyValueOperator(String key, Object value, NSSelector op) {
Object aValue = value;
try {
EOClassDescription classDescription = _dataSource != null ? _dataSource.classDescriptionForObjects() : null;
aValue = classDescription != null ? classDescription.validateValueForKey(aValue, key) : aValue;
} catch (NSValidation.ValidationException e) {
NSLog._conditionallyLogPrivateException(e);
}
NSSelector knownOp;
if (op == EOQualifier.QualifierOperatorEqual) {
String operatorString = (String) _queryOperator.objectForKey(key);
if (operatorString == null) {
operatorString = QUERYOPERATOR_DEFAULTSTRING;
}
if (!(aValue instanceof String)) {
if (operatorString.compareTo(QUERYOPERATOR_DEFAULTSTRING) == 0)
operatorString = "=";
} else {
String valueString = (String) aValue;
int length = valueString.length();
if (length == 0) {
return null;
}
if (operatorString.compareTo("is") == 0) {
operatorString = "=";
} else {
StringBuilder buffer = new StringBuilder(length + 4);
if (operatorString.compareTo(QUERYOPERATOR_DEFAULTSTRING) == 0) {
if (_DSMFindexOfObject > 0) {
buffer.append(_defaultStringMatchFormat, 0, _DSMFindexOfObject);
}
buffer.append(valueString);
int i = _DSMFindexOfObject + 2;
if (i < _defaultStringMatchFormat.length) {
buffer.append(_defaultStringMatchFormat, i, _defaultStringMatchFormat.length - i);
}
aValue = buffer.toString();
operatorString = _defaultStringMatchOperator;
} else if (operatorString.compareTo("starts with") == 0) {
buffer.append(valueString);
buffer.append(QUERYOPERATOR_WILDCARD);
aValue = buffer.toString();
operatorString = _defaultStringMatchOperator;
} else if (operatorString.compareTo("ends with") == 0) {
buffer.append(QUERYOPERATOR_WILDCARD);
buffer.append(valueString);
aValue = buffer.toString();
operatorString = _defaultStringMatchOperator;
} else if (operatorString.compareTo("contains") == 0) {
buffer.append(QUERYOPERATOR_WILDCARD);
buffer.append(valueString);
buffer.append(QUERYOPERATOR_WILDCARD);
aValue = buffer.toString();
operatorString = _defaultStringMatchOperator;
}
buffer = null;
}
}
knownOp = EOQualifier.operatorSelectorForString(operatorString);
} else {
knownOp = op;
}
if (knownOp == null) {
NSLog.err.appendln("***Error: unknown operator. Discarding query parameter " + key + " "
+ _queryOperator.objectForKey(key) + " " + aValue);
return null;
}
return new EOKeyValueQualifier(key, knownOp, aValue);
}
private void _addQualifiersToArrayForValuesOperator(NSMutableArray qualifiers, NSDictionary values, NSSelector op) {
Enumeration enumerator = values.keyEnumerator();
while (enumerator.hasMoreElements()) {
String key = (String) enumerator.nextElement();
Object value = values.valueForKey(key);
if (value != null) {
EOQualifier qualifier = _qualifierForKeyValueOperator(key, value, op);
if (qualifier != null)
qualifiers.addObject(qualifier);
}
}
}
public String defaultStringMatchOperator() {
return _defaultStringMatchOperator;
}
public void setDefaultStringMatchOperator(String op) {
_defaultStringMatchOperator = op;
}
public String defaultStringMatchFormat() {
return new String(_defaultStringMatchFormat);
}
public void setDefaultStringMatchFormat(String format) {
String aFormat = format != null ? format : QUERYMATCH_DEFAULTSTRING;
int i = aFormat.indexOf("%@");
if (i < 0) {
throw new IllegalArgumentException("DisplayGroup.setDefaultStringMatchFormat() : illegal format string \""
+ aFormat + "\". It must contain \"%@\".");
}
_defaultStringMatchFormat = aFormat.toCharArray();
_DSMFindexOfObject = i;
}
public EOQualifier qualifierFromQueryValues() {
NSMutableArray qualifiers = new NSMutableArray();
_addQualifiersToArrayForValuesOperator(qualifiers, _queryMax, EOQualifier.QualifierOperatorLessThanOrEqualTo);
_addQualifiersToArrayForValuesOperator(qualifiers, _queryMin, EOQualifier.QualifierOperatorGreaterThanOrEqualTo);
_addQualifiersToArrayForValuesOperator(qualifiers, _queryMatch, EOQualifier.QualifierOperatorEqual);
int count = qualifiers.count();
if (count == 0)
return null;
if (count == 1) {
return (EOQualifier) qualifiers.objectAtIndex(0);
}
return new EOAndQualifier(qualifiers);
}
public void qualifyDisplayGroup() {
setInQueryMode(false);
setQualifier(qualifierFromQueryValues());
updateDisplayedObjects();
}
public void qualifyDataSource() {
endEditing();
setInQueryMode(false);
NSSelector qualifierSetter = null;
if (_customDataSourceClass) {
if (SetAuxiliaryQualifier.implementedByObject(_dataSource))
qualifierSetter = SetAuxiliaryQualifier;
else if (SetQualifier.implementedByObject(_dataSource)) {
qualifierSetter = SetQualifier;
}
}
if (qualifierSetter != null) {
try {
qualifierSetter.invoke(_dataSource, qualifierFromQueryValues());
} catch (Exception e) {
throw NSForwardException._runtimeExceptionForThrowable(e);
}
}
fetch();
setCurrentBatchIndex(1);
}
@Deprecated
public void setInQueryMode(boolean yn) {
if (yn != inQueryMode())
if (yn) {
_savedAllObjects = _allObjects;
setObjectArray(new NSArray(_queryMatch));
selectObject(_queryMatch);
} else {
NSArray oldArray = _savedAllObjects;
_savedAllObjects = null;
setObjectArray(oldArray);
}
}
@Deprecated
public boolean inQueryMode() {
return _savedAllObjects != null;
}
private void _presentAlertWithTitleMessage(String title, String message) {
NSLog.err.appendln("<" + getClass().getName() + " " + title + ":" + message + "");
}
public void encodeWithKeyValueArchiver(EOKeyValueArchiver archiver) {
archiver.encodeInt(_numberOfObjectsPerBatch, "numberOfObjectsPerBatch");
archiver.encodeBool(fetchesOnLoad(), "fetchesOnLoad");
archiver.encodeBool(validatesChangesImmediately(), "validatesChangesImmediately");
archiver.encodeBool(selectsFirstObjectAfterFetch(), "selectsFirstObjectAfterFetch");
archiver.encodeObject(localKeys(), LocalKeysFieldKey);
archiver.encodeObject(_dataSource, DataSourceFieldKey);
archiver.encodeObject(_sortOrdering, SortOrderingFieldKey);
archiver.encodeObject(_qualifier, QualifierFieldKey);
archiver.encodeObject(defaultStringMatchFormat(), "formatForLikeQualifier");
archiver.encodeObject(_insertedObjectDefaultValues, "insertedObjectDefaultValues");
}
public static Object decodeWithKeyValueUnarchiver(EOKeyValueUnarchiver unarchiver) {
return new WODisplayGroup(unarchiver);
}
private WODisplayGroup(EOKeyValueUnarchiver unarchiver) {
_init(false);
setNumberOfObjectsPerBatch(unarchiver.decodeIntForKey("numberOfObjectsPerBatch"));
setFetchesOnLoad(unarchiver.decodeBoolForKey("fetchesOnLoad"));
setValidatesChangesImmediately(unarchiver.decodeBoolForKey("validatesChangesImmediately"));
setSelectsFirstObjectAfterFetch(unarchiver.decodeBoolForKey("selectsFirstObjectAfterFetch"));
setLocalKeys((NSArray) unarchiver.decodeObjectForKey(LocalKeysFieldKey));
_dataSource = ((EODataSource) unarchiver.decodeObjectForKey(DataSourceFieldKey));
setSortOrderings((NSArray) unarchiver.decodeObjectForKey(SortOrderingFieldKey));
setQualifier((EOQualifier) unarchiver.decodeObjectForKey(QualifierFieldKey));
setDefaultStringMatchFormat((String) unarchiver.decodeObjectForKey("formatForLikeQualifier"));
NSDictionary temp = (NSDictionary) unarchiver.decodeObjectForKey("insertedObjectDefaultValues");
if (temp == null) {
temp = NSDictionary.EmptyDictionary;
}
setInsertedObjectDefaultValues(temp);
finishInitialization();
}
public void awakeFromKeyValueUnarchiver(EOKeyValueUnarchiver unarchiver) {
if (_dataSource != null) {
unarchiver.ensureObjectAwake(_dataSource);
}
if (fetchesOnLoad())
fetch();
}
public NSArray relationalQualifierOperators() {
return EOQualifier.relationalQualifierOperators();
}
public NSArray allQualifierOperators() {
return _allQualifierOperators;
}
public NSArray stringQualifierOperators() {
return _stringQualifierOperators;
}
public void setNumberOfObjectsPerBatch(int count) {
if (count < 0) {
throw new IllegalArgumentException("WODisplayGroup.setNumberOfObjectsPerBatch(): invalid count " + count);
}
if (_numberOfObjectsPerBatch != count) {
clearSelection();
}
_numberOfObjectsPerBatch = count;
_batchIndex = 1;
}
public int numberOfObjectsPerBatch() {
return _numberOfObjectsPerBatch;
}
public Object displayNextBatch() {
if (_numberOfObjectsPerBatch == 0) {
return null;
}
setCurrentBatchIndex(_batchIndex + 1);
clearSelection();
return null;
}
public Object displayPreviousBatch() {
if (_numberOfObjectsPerBatch == 0) {
return null;
}
setCurrentBatchIndex(_batchIndex - 1);
clearSelection();
return null;
}
public int batchCount() {
if (_numberOfObjectsPerBatch == 0) {
return 0;
}
if (_displayedObjects.count() == 0) {
return 1;
}
return (_displayedObjects.count() - 1) / _numberOfObjectsPerBatch + 1;
}
public boolean hasMultipleBatches() {
return batchCount() > 1;
}
public int currentBatchIndex() {
return _batchIndex;
}
public void setCurrentBatchIndex(int batchIndex) {
if (_numberOfObjectsPerBatch == 0) {
return;
}
int bc = batchCount();
if (batchIndex > bc)
_batchIndex = 1;
else if (batchIndex < 1)
_batchIndex = (bc > 0 ? bc : 1);
else
_batchIndex = batchIndex;
}
public int indexOfFirstDisplayedObject() {
return _numberOfObjectsPerBatch * (currentBatchIndex() - 1) + 1;
}
public int indexOfLastDisplayedObject() {
int computedEnd = _numberOfObjectsPerBatch * currentBatchIndex();
int realEnd = allObjects().count();
if (_numberOfObjectsPerBatch == 0)
return realEnd;
return realEnd < computedEnd ? realEnd : computedEnd;
}
public Object displayBatchContainingSelectedObject() {
int batchIndex = 1;
int index = _selectionIndex();
if (batchCount() > 0) {
batchIndex = index / _numberOfObjectsPerBatch + 1;
}
if (_batchIndex != batchIndex) {
setCurrentBatchIndex(batchIndex);
return null;
}
return "";
}
public NSMutableDictionary queryMatch() {
return _queryMatch;
}
public NSMutableDictionary queryOperator() {
return _queryOperator;
}
public NSMutableDictionary queryMax() {
return _queryMax;
}
public NSMutableDictionary queryMin() {
return _queryMin;
}
public NSMutableDictionary queryBindings() {
return _queryBindings;
}
@Deprecated
public void editingContextPresentErrorMessage(EOEditingContext editingContext, String message) {
_presentAlertWithTitleMessage("EditingContext Error", message);
}
public Object insert() {
int index = _selectionIndex();
if (index < 0)
insertNewObjectAtIndex(_displayedObjects.count());
else {
insertNewObjectAtIndex(index + 1);
}
displayBatchContainingSelectedObject();
return null;
}
public Object delete() {
deleteSelection();
displayBatchContainingSelectedObject();
return null;
}
public String detailKey() {
if (hasDetailDataSource()) {
return ((EODetailDataSource) _dataSource).detailKey();
}
return null;
}
public void setDetailKey(String detailKey) {
if (hasDetailDataSource())
((EODetailDataSource) _dataSource).setDetailKey(detailKey);
}
public Object masterObject() {
if (hasDetailDataSource()) {
return ((EODetailDataSource) _dataSource).masterObject();
}
return null;
}
public void setMasterObject(Object masterObject) {
String detailKey = detailKey();
if (detailKey != null) {
_dataSource.qualifyWithRelationshipKey(detailKey, masterObject);
if (fetchesOnLoad())
fetch();
}
}
public boolean hasDetailDataSource() {
return _dataSource instanceof EODetailDataSource;
}
public void willChange() {
EOObserverCenter.notifyObserversObjectWillChange(this);
EOObserverCenter.notifyObserversObjectWillChange(null);
}
public Object valueForKey(String key) {
return NSKeyValueCoding.DefaultImplementation.valueForKey(this, key);
}
public void takeValueForKey(Object value, String key) {
NSKeyValueCoding.DefaultImplementation.takeValueForKey(this, value, key);
}
public Object handleQueryWithUnboundKey(String key) {
return NSKeyValueCoding.DefaultImplementation.handleQueryWithUnboundKey(this, key);
}
public void handleTakeValueForUnboundKey(Object value, String key) {
NSKeyValueCoding.DefaultImplementation.handleTakeValueForUnboundKey(this, value, key);
}
public void unableToSetNullForKey(String key) {
if (key.equals("numberOfObjectsPerBatch"))
setNumberOfObjectsPerBatch(0);
else
NSKeyValueCoding.DefaultImplementation.unableToSetNullForKey(this, key);
}
@Override
public String toString() {
StringBuilder sb = new StringBuilder();
sb.append('<');
sb.append(getClass().getName());
sb.append(" dataSource=");
sb.append(_dataSource);
sb.append(" delegate=");
sb.append(_delegate);
sb.append(" sortOrdering=");
sb.append(_sortOrdering);
sb.append(" qualifier=");
sb.append(_qualifier);
sb.append(" localKeys=");
sb.append(_localKeys);
sb.append(" insertedObjectDefaultValues=");
sb.append(_insertedObjectDefaultValues);
sb.append(" numberOfObjectsPerBatch=");
sb.append(_numberOfObjectsPerBatch);
sb.append('>');
return sb.toString();
}
static {
_stringQualifierOperators = new NSArray(new String[] { "starts with", "contains", "ends with", "is", "like" });
_allQualifierOperators = _stringQualifierOperators.arrayByAddingObjectsFromArray(EOQualifier
.relationalQualifierOperators());
}
public static abstract interface Delegate {
public abstract boolean displayGroupShouldRefetchForInvalidatedAllObjects(WODisplayGroup paramWODisplayGroup,
NSNotification paramNSNotification);
public abstract boolean displayGroupShouldChangeSelectionToIndexes(WODisplayGroup paramWODisplayGroup,
NSArray paramNSArray);
public abstract void displayGroupDidChangeSelectedObjects(WODisplayGroup paramWODisplayGroup);
public abstract void displayGroupDidChangeSelection(WODisplayGroup paramWODisplayGroup);
public abstract boolean displayGroupShouldFetch(WODisplayGroup paramWODisplayGroup);
public abstract void displayGroupDidFetchObjects(WODisplayGroup paramWODisplayGroup, NSArray paramNSArray);
public abstract NSArray displayGroupDisplayArrayForObjects(WODisplayGroup paramWODisplayGroup,
NSArray paramNSArray);
public abstract void displayGroupCreateObjectFailedForDataSource(WODisplayGroup paramWODisplayGroup,
EODataSource paramEODataSource);
public abstract boolean displayGroupShouldInsertObject(WODisplayGroup paramWODisplayGroup, Object paramObject,
int paramInt);
public abstract void displayGroupDidInsertObject(WODisplayGroup paramWODisplayGroup, Object paramObject);
public abstract boolean displayGroupShouldDeleteObject(WODisplayGroup paramWODisplayGroup, Object paramObject);
public abstract void displayGroupDidDeleteObject(WODisplayGroup paramWODisplayGroup, Object paramObject);
public abstract void displayGroupDidChangeDataSource(WODisplayGroup paramWODisplayGroup);
@Deprecated
public abstract boolean displayGroupShouldDisplayAlert(WODisplayGroup paramWODisplayGroup, String paramString1,
String paramString2);
}
}