public virtual bool remove(object @object)
{
java.util.Iterator <E> it = iterator();
if (@object != null)
{
while (it.hasNext())
{
if (@object.Equals(it.next()))
{
it.remove();
return(true);
}
}
}
else
{
while (it.hasNext())
{
if (it.next() == null)
{
it.remove();
return(true);
}
}
}
return(false);
}
/**
* Adds an delete change.
*
* @param pChange
* the change which should result in a deletion
*/
private void addDeletion(Change pChange)
{
if ((Change.TYPE_DELETE != pChange.type() &&
Change.TYPE_DELETE_DIR != pChange.type()) ||
pChange.targetFile() == null)
{
return;
}
String source = pChange.targetFile();
if (!changes.isEmpty())
{
for (java.util.Iterator <Change> it = changes.iterator(); it.hasNext();)
{
Change change = (Change)it.next();
if (change.type() == Change.TYPE_ADD &&
change.getEntry() != null)
{
String target = change.getEntry().getName();
if (Change.TYPE_DELETE == pChange.type() && source.equals(target))
{
it.remove();
}
else if (Change.TYPE_DELETE_DIR == pChange.type() &&
target.matches(source + "/.*"))
{
it.remove();
}
}
}
}
changes.add(pChange);
}
public override bool retainAll(java.util.Collection <Object> coll)
{
bool result = collection.retainAll(coll);
if (result == false)
{
return(false);
}
else if (collection.size() == 0)
{
setOrder.clear();
}
else
{
for (java.util.Iterator <Object> it = setOrder.iterator(); it.hasNext();)
{
Object obj = it.next();
if (collection.contains(obj) == false)
{
it.remove();
}
}
}
return(result);
}
public override bool removeAll <_T0>(java.util.Collection <_T0> collection)
{
bool result = false;
if (size() <= collection.size())
{
java.util.Iterator <E> it = iterator();
while (it.hasNext())
{
if (collection.contains(it.next()))
{
it.remove();
result = true;
}
}
}
else
{
java.util.Iterator <_T0> it = collection.iterator();
while (it.hasNext())
{
result = remove(it.next()) || result;
}
}
return(result);
}
public void remove()
{
if (lastReturned == null)
{
throw new java.lang.IllegalStateException();
}
if (root.fast)
{
lock (root)
{
if (expected != root.map)
{
throw new java.util.ConcurrentModificationException();
}
root.remove(lastReturned.getKey());
lastReturned = null;
expected = root.map;
}
}
else
{
iterator.remove();
lastReturned = null;
}
}
/**
* Adds an addition change.
*
* @param pChange
* the change which should result in an addition
*/
private void addAddition(Change pChange)
{
if (Change.TYPE_ADD != pChange.type() ||
pChange.getInput() == null)
{
return;
}
if (!changes.isEmpty())
{
for (java.util.Iterator <Change> it = changes.iterator(); it.hasNext();)
{
Change change = it.next();
if (change.type() == Change.TYPE_ADD && change.getEntry() != null)
{
org.apache.commons.compress.archivers.ArchiveEntry entry = change.getEntry();
if (entry.equals(pChange.getEntry()))
{
if (pChange.isReplaceMode())
{
it.remove();
changes.add(pChange);
return;
}
else
{
// do not add this change
return;
}
}
}
}
}
changes.add(pChange);
}
/**
* Removes from the underlying collection of the base iterator the last
* element returned by this iterator.
* This method can only be called
* if <code>next()</code> was called, but not after
* <code>hasNext()</code>, because the <code>hasNext()</code> call
* changes the base iterator.
*
* @throws IllegalStateException if <code>hasNext()</code> has already
* been called.
*/
public void remove()
{
if (nextObjectSet)
{
throw new java.lang.IllegalStateException("remove() cannot be called");
}
iterator.remove();
}
public void remove()
{
iterator.remove();
if (values.isEmpty())
{
root.remove(key);
}
}
public void remove()
{
if (tempIterator == null)
{
throw new java.lang.IllegalStateException();
}
tempIterator.remove();
}
/**
* Removes from the underlying collection the last element returned.
* <p>
* This method calls remove() on the underlying Iterator and it may
* throw an UnsupportedOperationException if the underlying Iterator
* does not support this method.
*
* @throws UnsupportedOperationException
* if the remove operator is not supported by the underlying Iterator
* @throws IllegalStateException
* if the next method has not yet been called, or the remove method has
* already been called after the last call to the next method.
*/
public void remove()
{
if (lastUsedIterator == null)
{
throw new java.lang.IllegalStateException("Iterator remove() cannot be called at this time");
}
lastUsedIterator.remove();
lastUsedIterator = null;
}
/**
* Removes from the underlying collection the last element
* returned by the Iterator. As with next() and hasNext(),
* this method calls remove() on the underlying Iterator.
* Therefore, this method may throw an
* UnsupportedOperationException if the underlying
* Iterator does not support this method.
*
* @throws UnsupportedOperationException
* if the remove operator is not supported by the underlying Iterator
* @throws IllegalStateException
* if the next method has not yet been called, or the remove method has
* already been called after the last call to the next method.
*/
public void remove()
{
lockChain();
if (currentIterator == null)
{
updateCurrentIterator();
}
lastUsedIterator.remove();
}
/**
* Removes the last returned element from the child iterator that
* produced it.
*
* @throws IllegalStateException if there is no last returned element,
* or if the last returned element has already been removed
*/
public virtual void remove()
{
if (lastReturned == -1)
{
throw new java.lang.IllegalStateException("No value can be removed at present");
}
java.util.Iterator <Object> it = (java.util.Iterator <Object>)(iterators.get(lastReturned));
it.remove();
}
public override void clear()
{
// override as default implementation jumps to [1]
for (java.util.Iterator <Object> it = keySet().iterator(); it.hasNext();)
{
it.next();
it.remove();
}
}
public virtual void clear()
{
java.util.Iterator i = iterator();
while (i.hasNext())
{
i.next();
i.remove();
}
}
public virtual void clear()
{
java.util.Iterator <E> it = iterator();
while (it.hasNext())
{
it.next();
it.remove();
}
}
public virtual void remove()
{
if (_parent.modCount() != _mods)
{
throw new java.util.ConcurrentModificationException();
}
_support.remove();
_parent.remove(_current, 1);
_mods++;
}
public override void clear()
{
checkModCount();
java.util.Iterator <Object> it = iterator();
while (it.hasNext())
{
it.next();
it.remove();
}
}
//-----------------------------------------------------------------------
/**
* Removes the last returned key from the underlying <code>Map</code>.
* <p>
* This method can be called once per call to <code>next()</code>.
*
* @throws UnsupportedOperationException if remove is not supported by the map
* @throws IllegalStateException if <code>next()</code> has not yet been called
* @throws IllegalStateException if <code>remove()</code> has already been called
* since the last call to <code>next()</code>
*/
public void remove()
{
if (canRemove == false)
{
throw new java.lang.IllegalStateException("Iterator remove() can only be called once after next()");
}
iterator.remove();
last = null;
canRemove = false;
}
/**
* Deregisters a cursor from the list to be notified of changes.
*
* @param cursor the cursor to deregister
*/
protected virtual void unregisterCursor(Cursor cursor)
{
for (java.util.Iterator <Object> it = cursors.iterator(); it.hasNext();)
{
java.lang.refj.WeakReference <Object> refJ = (java.lang.refj.WeakReference <Object>)it.next();
Cursor cur = (Cursor)refJ.get();
if (cur == null)
{
// some other unrelated cursor object has been
// garbage-collected; let's take the opportunity to
// clean up the cursors list anyway..
it.remove();
}
else if (cur == cursor)
{
refJ.clear();
it.remove();
break;
}
}
}
/**
* Removes all nodes by iteration.
*/
protected override void removeAllNodes()
{
if (size() > 0)
{
// superclass implementation would break all the iterators
java.util.Iterator <Object> it = iterator();
while (it.hasNext())
{
it.next();
it.remove();
}
}
}
//-----------------------------------------------------------------------
/**
* Registers a cursor to be notified of changes to this list.
*
* @param cursor the cursor to register
*/
protected virtual void registerCursor(Cursor cursor)
{
// We take this opportunity to clean the cursors list
// of WeakReference objects to garbage-collected cursors.
for (java.util.Iterator <Object> it = cursors.iterator(); it.hasNext();)
{
java.lang.refj.WeakReference <Object> refJ = (java.lang.refj.WeakReference <Object>)it.next();
if (refJ.get() == null)
{
it.remove();
}
}
cursors.add(new java.lang.refj.WeakReference <Object>(cursor));
}
// Equals // default object behaviour
public virtual bool remove(object o)
{
java.util.Iterator i = iterator();
while (i.hasNext())
{
object e = i.next();
if (o == null ? e == null : o.Equals(e))
{
i.remove();
return(true);
}
}
return(false);
}
public void remove()
{
if (canRemove == false)
{
throw new java.lang.IllegalStateException("Iterator remove() can only be called once after next()");
}
// store value as remove may change the entry in the decorator (eg.TreeMap)
Object value = last.getValue();
iterator.remove();
parent.maps[1].remove(value);
last = null;
canRemove = false;
}
public virtual bool retainAll <_T0>(java.util.Collection <_T0> collection)
{
bool result = false;
java.util.Iterator <E> it = iterator();
while (it.hasNext())
{
if (!collection.contains(it.next()))
{
it.remove();
result = true;
}
}
return(result);
}
//-----------------------------------------------------------------------
public virtual bool retainAll(java.util.Collection <Object> coll)
{
bool modified = false;
java.util.Iterator <Object> it = iterator();
while (it.hasNext())
{
if (coll.contains(it.next()) == false)
{
it.remove();
modified = true;
}
}
return(modified);
}
/**
* Removes the first n entries in the map, where n is the number of entries in the map beyond its capacity. Note
* that the entry set and the corresponding iterator are backed by the map itself, so changes to an entry iterator
* correspond to changes in the map. We use the iterator's remove() method because we're removing elements from the
* entry set as we iterate over them.
*/
protected void removeOverCapacityEntries()
{
int count = this.size() - this.getCapacity();
if (count <= 0)
{
return;
}
java.util.Iterator <java.util.Map.Entry <K, V> > iter = this.entrySet().iterator();
for (int i = 0; i < count && iter.hasNext(); i++)
{
iter.next();
iter.remove();
}
}
public virtual bool removeAll(Collection c)
{
java.util.Iterator i = iterator();
bool didremove = false;
while (i.hasNext())
{
object o = i.next();
if (c.contains(o))
{
didremove = true;
i.remove();
}
}
return(didremove);
}
public static bool removeIf(Collection @this, java.util.function.Predicate predicate)
{
java.util.Iterator i = @this.iterator();
bool didremove = false;
while (i.hasNext())
{
object o = i.next();
if (predicate.test(o))
{
didremove = true;
i.remove();
}
}
return(didremove);
}
/**
* Informs all of my registered cursors that the specified
* element was just added to my list.
*
* @param node the node that was changed
*/
protected virtual void broadcastNodeInserted(Node node)
{
java.util.Iterator <Object> it = cursors.iterator();
while (it.hasNext())
{
java.lang.refj.WeakReference <Object> refJ = (java.lang.refj.WeakReference <Object>)it.next();
Cursor cursor = (Cursor)refJ.get();
if (cursor == null)
{
it.remove(); // clean up list
}
else
{
cursor.nodeInserted(node);
}
}
}
public override bool removeAll(java.util.Collection <Object> coll)
{
if (parent.isEmpty() || coll.isEmpty())
{
return(false);
}
bool modified = false;
java.util.Iterator <Object> it = iterator();
while (it.hasNext())
{
if (coll.contains(it.next()))
{
it.remove();
modified = true;
}
}
return(modified);
}