/**
* Create a new Closure that calls one of the closures depending
* on the predicates.
* <p>
* The Map consists of Predicate keys and Closure values. A closure
* is called if its matching predicate returns true. Each predicate is evaluated
* until one returns true. If no predicates evaluate to true, the default
* closure is called. The default closure is set in the map with a
* null key. The ordering is that of the iterator() method on the entryset
* collection of the map.
*
* @param predicatesAndClosures a map of predicates to closures
* @return the <code>switch</code> closure
* @throws IllegalArgumentException if the map is null
* @throws IllegalArgumentException if any closure in the map is null
* @throws ClassCastException if the map elements are of the wrong type
*/
public static Closure getInstance(java.util.Map <Object, Object> predicatesAndClosures)
{
Closure[] closures = null;
Predicate[] preds = null;
if (predicatesAndClosures == null)
{
throw new java.lang.IllegalArgumentException("The predicate and closure map must not be null");
}
if (predicatesAndClosures.size() == 0)
{
return(NOPClosure.INSTANCE);
}
// convert to array like this to guarantee iterator() ordering
Closure defaultClosure = (Closure)predicatesAndClosures.remove(null);
int size = predicatesAndClosures.size();
if (size == 0)
{
return(defaultClosure == null ? NOPClosure.INSTANCE : defaultClosure);
}
closures = new Closure[size];
preds = new Predicate[size];
int i = 0;
for (java.util.Iterator <Object> it = (java.util.Iterator <Object>)predicatesAndClosures.entrySet().iterator(); it.hasNext();)
{
java.util.MapNS.Entry <Object, Object> entry = (java.util.MapNS.Entry <Object, Object>)it.next();
preds[i] = (Predicate)entry.getKey();
closures[i] = (Closure)entry.getValue();
i++;
}
return(new SwitchClosure(preds, closures, defaultClosure));
}
public override Object[] toArray <Object>(Object[] array)
{
Object[] result = array;
if (array.Length > 0)
{
// we must create a new array to handle multi-threaded situations
// where another thread could access data before we decorate it
//result = (Object[]) Array.newInstance(array.getClass().getComponentType(), 0);
result = new Object[array.Length];
}
Object [] input = collection.toArray(result);
for (int i = 0; i < result.Length; i++)
{
java.util.MapNS.Entry <object, object> makeUnmodifiable = (java.util.MapNS.Entry <object, object>)input[i];
UnmodifiableEntry ue = new UnmodifiableEntry(makeUnmodifiable);
result[i] = ((Object)(object)ue);
}
// check to see if result should be returned straight
if (result.Length > array.Length)
{
return(result);
}
// copy back into input array to fulfil the method contract
java.lang.SystemJ.arraycopy(result, 0, array, 0, result.Length);
if (array.Length > result.Length)
{
array[result.Length] = default(Object);
}
return(array);
}
/**
* Create a new Transformer that calls one of the transformers depending
* on the predicates.
* <p>
* The Map consists of Predicate keys and Transformer values. A transformer
* is called if its matching predicate returns true. Each predicate is evaluated
* until one returns true. If no predicates evaluate to true, the default
* transformer is called. The default transformer is set in the map with a
* null key. The ordering is that of the iterator() method on the entryset
* collection of the map.
*
* @param predicatesAndTransformers a map of predicates to transformers
* @return the <code>switch</code> transformer
* @throws IllegalArgumentException if the map is null
* @throws IllegalArgumentException if any transformer in the map is null
* @throws ClassCastException if the map elements are of the wrong type
*/
public static Transformer getInstance(java.util.Map <Object, Object> predicatesAndTransformers)
{
Transformer[] transformers = null;
Predicate[] preds = null;
if (predicatesAndTransformers == null)
{
throw new java.lang.IllegalArgumentException("The predicate and transformer map must not be null");
}
if (predicatesAndTransformers.size() == 0)
{
return(ConstantTransformer.NULL_INSTANCE);
}
// convert to array like this to guarantee iterator() ordering
Transformer defaultTransformer = (Transformer)predicatesAndTransformers.remove(null);
int size = predicatesAndTransformers.size();
if (size == 0)
{
return(defaultTransformer == null ? ConstantTransformer.NULL_INSTANCE : defaultTransformer);
}
transformers = new Transformer[size];
preds = new Predicate[size];
int i = 0;
for (java.util.Iterator <Object> it = (java.util.Iterator <Object>)predicatesAndTransformers.entrySet().iterator(); it.hasNext();)
{
java.util.MapNS.Entry <Object, Object> entry = (java.util.MapNS.Entry <Object, Object>)it.next();
preds[i] = (Predicate)entry.getKey();
transformers[i] = (Transformer)entry.getValue();
i++;
}
return(new SwitchTransformer(preds, transformers, defaultTransformer));
}
//-----------------------------------------------------------------------
/**
* Returns the Map as a string.
*
* @return the Map as a String
*/
public override String ToString()
{
if (isEmpty())
{
return("{}");
}
java.lang.StringBuffer buf = new java.lang.StringBuffer();
buf.append('{');
bool first = true;
java.util.Iterator <Object> it = entrySet().iterator();
while (it.hasNext())
{
java.util.MapNS.Entry <Object, Object> entry = (java.util.MapNS.Entry <Object, Object>)it.next();
Object key = entry.getKey();
Object value = entry.getValue();
if (first)
{
first = false;
}
else
{
buf.append(", ");
}
buf.append(key == this ? "(this Map)" : key);
buf.append('=');
buf.append(value == this ? "(this Map)" : value);
}
buf.append('}');
return(buf.toString());
}
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;
}
}
public bool ignoreGlobalAllowedByRobots(java.util.List <String> userAgents, String url)
{
String path = getPath(url);
java.util.MapNS.Entry <Match, Match> matches = computeMatchPriorities(userAgents, path, true);
return(allowVerdict(matches.getKey(), matches.getValue()));
}
/**
* Constructor that wraps (not copies).
*
* @param entry the <code>Map.Entry</code> to decorate, must not be null
* @throws IllegalArgumentException if the collection is null
*/
public AbstractMapEntryDecorator(java.util.MapNS.Entry <Object, Object> entry)
{
if (entry == null)
{
throw new java.lang.IllegalArgumentException("Map Entry must not be null");
}
this.entry = entry;
}
public override void putAll(java.util.Map <Object, Object> map)
{
for (java.util.Iterator <java.util.MapNS.Entry <Object, Object> > it = map.entrySet().iterator(); it.hasNext();)
{
java.util.MapNS.Entry <Object, Object> entry = it.next();
put(entry.getKey(), entry.getValue());
}
}
/**
* Constructor.
*
* @param parent the parent bag
*/
public BagIterator(AbstractMapBag parent)
{
this.parent = parent;
this.entryIterator = parent.map.entrySet().iterator();
this.current = null;
this.mods = parent.modCount;
this.canRemove = false;
}
public virtual void remove()
{
if (last == null)
{
throw new java.lang.IllegalStateException();
}
root.remove(last.getKey());
last = null;
}
/**
* Adds all the mappings in the specified map to this map, replacing any
* mappings that already exist (as per {@link Map#putAll(Map)}). The order
* in which the entries are added is determined by the iterator returned
* from {@link Map#entrySet()} for the specified map.
*
* @param t the mappings that should be added to this map.
*
* @throws NullPointerException if <code>t</code> is <code>null</code>
*/
public virtual void putAll(java.util.Map <Object, Object> t)
{
java.util.Iterator <java.util.MapNS.Entry <Object, Object> > iter = t.entrySet().iterator();
while (iter.hasNext())
{
java.util.MapNS.Entry <Object, Object> entry = iter.next();
put(entry.getKey(), entry.getValue());
}
}
public Object next()
{
if (expected != root.map)
{
throw new java.util.ConcurrentModificationException();
}
lastReturned = (java.util.MapNS.Entry <Object, Object>)iterator.next();
return(view.iteratorNext(lastReturned));
}
protected virtual java.util.MapNS.Entry <Object, Object> nextEntry()
{
if (!hasNext())
{
throw new java.util.NoSuchElementException();
}
last = (java.util.MapNS.Entry <Object, Object>)current.remove(current.size() - 1);
return(last);
}
/**
* Constructor copying elements from another map.
*
* @param map the map to copy, must be size 1
* @throws NullPointerException if the map is null
* @throws IllegalArgumentException if the size is not 1
*/
public SingletonMap(java.util.Map <Object, Object> map)
{
if (map.size() != 1)
{
throw new java.lang.IllegalArgumentException("The map size must be 1");
}
java.util.MapNS.Entry <Object, Object> entry = (java.util.MapNS.Entry <Object, Object>)map.entrySet().iterator().next();
this.key = entry.getKey();
this.value = entry.getValue();
}
//-----------------------------------------------------------------------
/**
* 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;
}
//-----------------------------------------------------------------------
/**
* Write the map out using a custom routine.
* @param out the output stream
* @throws IOException
*/
protected virtual void doWriteObject(java.io.ObjectOutputStream outJ)
{//throws IOException {
outJ.writeInt(map.size());
for (java.util.Iterator <java.util.MapNS.Entry <Object, Object> > it = map.entrySet().iterator(); it.hasNext();)
{
java.util.MapNS.Entry <Object, Object> entry = (java.util.MapNS.Entry <Object, Object>)it.next();
outJ.writeObject(entry.getKey());
outJ.writeInt(((MutableInteger)entry.getValue()).value);
}
}
public override void putAll(java.util.Map <Object, Object> mapToCopy)
{
java.util.Iterator <java.util.MapNS.Entry <Object, Object> > it = mapToCopy.entrySet().iterator();
while (it.hasNext())
{
java.util.MapNS.Entry <Object, Object> entry = (java.util.MapNS.Entry <Object, Object>)it.next();
Object key = entry.getKey();
Object value = entry.getValue();
validate(key, value);
}
map.putAll(mapToCopy);
}
/**
* Clear the map.
* <p>
* This clears each collection in the map, and so may be slow.
*/
public override void clear()
{
// For gc, clear each list in the map
java.util.Set <java.util.MapNS.Entry <Object, Object> > pairs = base.entrySet();
java.util.Iterator <java.util.MapNS.Entry <Object, Object> > pairsIterator = pairs.iterator();
while (pairsIterator.hasNext())
{
java.util.MapNS.Entry <Object, Object> keyValuePair = pairsIterator.next();
java.util.Collection <Object> coll = (java.util.Collection <Object>)keyValuePair.getValue();
coll.clear();
}
base.clear();
}
/**
* Gets a hash code for the Bag compatible with the definition of equals.
* The hash code is defined as the sum total of a hash code for each element.
* The per element hash code is defined as
* <code>(e==null ? 0 : e.hashCode()) ^ noOccurances)</code>.
* This hash code is compatible with the Set interface.
*
* @return the hash code of the Bag
*/
public override int GetHashCode()
{
int total = 0;
for (java.util.Iterator <java.util.MapNS.Entry <Object, Object> > it = map.entrySet().iterator(); it.hasNext();)
{
java.util.MapNS.Entry <Object, Object> entry = (java.util.MapNS.Entry <Object, Object>)it.next();
Object element = entry.getKey();
MutableInteger count = (MutableInteger)entry.getValue();
total += (element == null ? 0 : element.GetHashCode()) ^ count.value;
}
return(total);
}
public override Object[] toArray <Object>(Object[] arr)
{
// special implementation to handle disappearing entries
java.util.ArrayList <Object> list = new java.util.ArrayList <Object>();
java.util.Iterator <Object> it = (java.util.Iterator <Object>) this.iterator();
while (it.hasNext())
{
java.util.MapNS.Entry <Object, Object> e = (java.util.MapNS.Entry <Object, Object>)it.next(); //? right???
object o = new DefaultMapEntry(e.getKey(), e.getValue());
Object o2 = (Object)o;
list.add(o2);
}
return(list.toArray(arr));
}
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;
}
/**
* Transforms a map.
* <p>
* The transformer itself may throw an exception if necessary.
*
* @param map the map to transform
* @throws the transformed object
*/
protected virtual java.util.Map <Object, Object> transformMap(java.util.Map <Object, Object> map)
{
if (map.isEmpty())
{
return(map);
}
java.util.Map <Object, Object> result = new LinkedMap(map.size());
for (java.util.Iterator <java.util.MapNS.Entry <Object, Object> > it = map.entrySet().iterator(); it.hasNext();)
{
java.util.MapNS.Entry <Object, Object> entry = it.next();
result.put(transformKey(entry.getKey()), transformValue(entry.getValue()));
}
return(result);
}
//-----------------------------------------------------------------------
/**
* Clones the map creating an independent copy.
* <p>
* The clone will shallow clone the collections as well as the map.
*
* @return the cloned map
*/
public Object clone()
{
MultiHashMap cloned = (MultiHashMap)base.MemberwiseClone();
// clone each Collection container
for (java.util.Iterator <java.util.MapNS.Entry <Object, Object> > it = cloned.entrySet().iterator(); it.hasNext();)
{
java.util.MapNS.Entry <Object, Object> entry = it.next();
java.util.Collection <Object> coll = (java.util.Collection <Object>)entry.getValue();
java.util.Collection <Object> newColl = createCollection(coll);
entry.setValue(newColl);
}
return(cloned);
}
public Object next()
{
if (parent.modCount != mods)
{
throw new java.util.ConcurrentModificationException();
}
if (itemCount == 0)
{
current = (java.util.MapNS.Entry <Object, Object>)entryIterator.next();
itemCount = ((MutableInteger)current.getValue()).value;
}
canRemove = true;
itemCount--;
return(current.getKey());
}
// Basics
//-----------------------------------------------------------------------
/**
* Compares this Map Entry with another Map Entry.
* <p>
* Implemented per API documentation of {@link java.util.Map.Entry#equals(Object)}
*
* @param obj the object to compare to
* @return true if equal key and value
*/
public override bool Equals(Object obj)
{
if (obj == this)
{
return(true);
}
if (obj is java.util.MapNS.Entry <Object, Object> == false)
{
return(false);
}
java.util.MapNS.Entry <Object, Object> other = (java.util.MapNS.Entry <Object, Object>)obj;
return
((getKey() == null ? other.getKey() == null : getKey().equals(other.getKey())) &&
(getValue() == null ? other.getValue() == null : getValue().equals(other.getValue())));
}
//-----------------------------------------------------------------------
/**
* Constructor that wraps (not copies).
*
* @param map the map to decorate, must not be null
* @param keyPredicate the predicate to validate the keys, null means no check
* @param valuePredicate the predicate to validate to values, null means no check
* @throws IllegalArgumentException if the map is null
*/
protected internal PredicatedMap(java.util.Map <Object, Object> map, Predicate keyPredicate, Predicate valuePredicate)
: base(map)
{
this.keyPredicate = keyPredicate;
this.valuePredicate = valuePredicate;
java.util.Iterator <java.util.MapNS.Entry <Object, Object> > it = map.entrySet().iterator();
while (it.hasNext())
{
java.util.MapNS.Entry <Object, Object> entry = (java.util.MapNS.Entry <Object, Object>)it.next();
Object key = entry.getKey();
Object value = entry.getValue();
validate(key, value);
}
}
public override bool Equals(Object obj)
{
if (obj == this)
{
return(true);
}
if (obj is java.util.MapNS.Entry <Object, Object> == false)
{
return(false);
}
java.util.MapNS.Entry <Object, Object> e2 = (java.util.MapNS.Entry <Object, Object>)obj;
return(
(key == null ? e2.getKey() == null : key.equals(e2.getKey())) &&
(value == null ? e2.getValue() == null : value.equals(e2.getValue())));
}
/**
* Puts the values from the specified map into this map.
* <p>
* The map must be of size 0 or size 1.
* If it is size 1, the key must match the key of this map otherwise an
* IllegalArgumentException is thrown.
*
* @param map the map to add, must be size 0 or 1, and the key must match
* @throws NullPointerException if the map is null
* @throws IllegalArgumentException if the key does not match
*/
public virtual void putAll(java.util.Map <Object, Object> map)
{
switch (map.size())
{
case 0:
return;
case 1:
java.util.MapNS.Entry <Object, Object> entry = (java.util.MapNS.Entry <Object, Object>)map.entrySet().iterator().next();
put(entry.getKey(), entry.getValue());
return;
default:
throw new java.lang.IllegalArgumentException("The map size must be 0 or 1");
}
}
/**
* Compares this <code>Map.Entry</code> with another <code>Map.Entry</code>.
* <p>
* Implemented per API documentation of {@link java.util.Map.Entry#equals(Object)}
*
* @param obj the object to compare to
* @return true if equal key and value
*/
public bool equals(Object obj)
{
if (obj == this)
{
return(true);
}
if (obj is java.util.MapNS.Entry <Object, Object> == false)
{
return(false);
}
java.util.MapNS.Entry <Object, Object> other = (java.util.MapNS.Entry <Object, Object>)obj;
Object value = getValue();
return
((key == null ? other.getKey() == null : key.equals(other.getKey())) &&
(value == null ? other.getValue() == null : value.equals(other.getValue())));
}
public override bool contains(Object obj)
{
java.util.MapNS.Entry <Object, Object> entry = (java.util.MapNS.Entry <Object, Object>)obj;
int hash = root.getHash(entry.getKey());
lock (root.locks[hash])
{
for (Node n = root.buckets[hash]; n != null; n = n.next)
{
if (n.equals(entry))
{
return(true);
}
}
}
return(false);
}
//-----------------------------------------------------------------------
/**
* Resets the state of the iterator.
*/
public void reset()
{
iterator = (java.util.Iterator<Object>)map.entrySet().iterator();
last = null;
canRemove = false;
}
public virtual void reset()
{
iterator = new java.util.ArrayList<Object>((java.util.Collection<Object>)parent.entrySet()).listIterator();
last = null;
}
public virtual void remove()
{
iterator.remove();
parent.remove(last.getKey());
last = null;
}
public virtual Object previous()
{
last = (java.util.MapNS.Entry<Object, Object>)iterator.previous();
return last.getKey();
}
/**
* Gets the next <em>key</em> from the <code>Map</code>.
*
* @return the next key in the iteration
* @throws java.util.NoSuchElementException if the iteration is finished
*/
public Object next()
{
last = (java.util.MapNS.Entry<Object, Object>)iterator.next();
canRemove = true;
return last.getKey();
}
//-----------------------------------------------------------------------
/**
* 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;
}
