public virtual void add(java.lang.Iterable i, params org.openrdf.model.Resource[] rarr)
{
IEnumerable<Uri> contexts = rarr.ToContexts(this._mapping);
Graph g = new Graph();
g.Assert(new JavaIteratorWrapper<dotSesame.Statement>(i.iterator()).Select(s => SesameConverter.FromSesame(s, this._mapping)));
this.AddInternal(g, contexts);
}
public static ArrayList ToArrayList(java.util.ArrayList jalist)
{
if(jalist == null) return null;
ArrayList alist = new ArrayList();
java.util.Iterator it = jalist.iterator();
while(it.hasNext())
{
alist.Add(it.next());
}
return alist;
}
//-----------------------------------------------------------------------
/**
* Constructor that wraps (not copies).
* <p>
* If there are any elements already in the collection being decorated, they
* are validated.
*
* @param coll the collection to decorate, must not be null
* @param predicate the predicate to use for validation, must not be null
* @throws IllegalArgumentException if collection or predicate is null
* @throws IllegalArgumentException if the collection contains invalid elements
*/
protected internal PredicatedCollection(java.util.Collection<Object> coll, Predicate predicate)
: base(coll)
{
if (predicate == null)
{
throw new java.lang.IllegalArgumentException("Predicate must not be null");
}
this.predicate = predicate;
for (java.util.Iterator<Object> it = coll.iterator(); it.hasNext(); )
{
validate(it.next());
}
}
/**
* Returns <code>true</code> iff at least one element is in both collections.
* <p>
* In other words, this method returns <code>true</code> iff the
* {@link #intersection} of <i>coll1</i> and <i>coll2</i> is not empty.
*
* @param coll1 the first collection, must not be null
* @param coll2 the first collection, must not be null
* @return <code>true</code> iff the intersection of the collections is non-empty
* @since 2.1
* @see #intersection
*/
public static bool containsAny(java.util.Collection<Object> coll1, java.util.Collection<Object> coll2)
{
if (coll1.size() < coll2.size())
{
for (java.util.Iterator<Object> it = coll1.iterator(); it.hasNext(); )
{
if (coll2.contains(it.next()))
{
return true;
}
}
}
else
{
for (java.util.Iterator<Object> it = coll2.iterator(); it.hasNext(); )
{
if (coll1.contains(it.next()))
{
return true;
}
}
}
return false;
}
/**
* Generates a hash code using the algorithm specified in
* {@link java.util.List#hashCode()}.
* <p>
* This method is useful for implementing <code>List</code> when you cannot
* extend AbstractList. The method takes Collection instances to enable other
* collection types to use the List implementation algorithm.
*
* @see java.util.List#hashCode()
* @param list the list to generate the hashCode for, may be null
* @return the hash code
*/
public static int hashCodeForList(java.util.Collection<Object> list)
{
if (list == null)
{
return 0;
}
int hashCode = 1;
java.util.Iterator<Object> it = list.iterator();
Object obj = null;
while (it.hasNext())
{
obj = it.next();
hashCode = 31 * hashCode + (obj == null ? 0 : obj.GetHashCode());
}
return hashCode;
}
/**
* Adds a collection of objects to the end of the list avoiding duplicates.
* <p>
* Only elements that are not already in this list will be added, and
* duplicates from the specified collection will be ignored.
* <p>
* <i>(Violation)</i>
* The <code>List</code> interface makes the assumption that the elements
* are always inserted. This may not happen with this implementation.
*
* @param index the index to insert at
* @param coll the collection to add in iterator order
* @return true if this collection changed
*/
public override bool addAll(int index, java.util.Collection<Object> coll)
{
// gets initial size
int sizeBefore = size();
// adds all elements
for (java.util.Iterator<Object> it = coll.iterator(); it.hasNext(); )
{
add(it.next());
}
// compares sizes to detect if collection changed
return sizeBefore != size();
}
/**
* Override to validate the objects being added to ensure they match
* the predicate. If any one fails, no update is made to the underlying
* collection.
*
* @param coll the collection being added
* @return the result of adding to the underlying collection
* @throws IllegalArgumentException if the add is invalid
*/
public override bool addAll(java.util.Collection<Object> coll)
{
for (java.util.Iterator<Object> it = coll.iterator(); it.hasNext(); )
{
validate(it.next());
}
return getCollection().addAll(coll);
}
public bool removeAll(java.util.Collection c)
{
JavaIteratorWrapper<dotSesame.Statement> stmtIter = new JavaIteratorWrapper<org.openrdf.model.Statement>(c.iterator());
bool removed = false;
foreach (dotSesame.Statement stmt in stmtIter)
{
Triple t = SesameConverter.FromSesame(stmt, this._mapping);
if (this._g.ContainsTriple(t))
{
this._g.Retract(t);
removed = removed || true;
}
}
return removed;
}
/**
* Transforms a collection.
* <p>
* The transformer itself may throw an exception if necessary.
*
* @param coll the collection to transform
* @return a transformed object
*/
protected virtual java.util.Collection<Object> transform(java.util.Collection<Object> coll)
{
java.util.List<Object> list = new java.util.ArrayList<Object>(coll.size());
for (java.util.Iterator<Object> it = coll.iterator(); it.hasNext(); )
{
list.add(transform(it.next()));
}
return list;
}
/**
* Returns a {@link Map} mapping each unique element in the given
* {@link Collection} to an {@link Integer} representing the number
* of occurrences of that element in the {@link Collection}.
* <p>
* Only those elements present in the collection will appear as
* keys in the map.
*
* @param coll the collection to get the cardinality map for, must not be null
* @return the populated cardinality map
*/
public static java.util.Map<Object, Object> getCardinalityMap(java.util.Collection<Object> coll)
{
java.util.Map<Object, Object> count = new java.util.HashMap<Object, Object>();
for (java.util.Iterator<Object> it = coll.iterator(); it.hasNext(); )
{
Object obj = it.next();
java.lang.Integer c = (java.lang.Integer)(count.get(obj));
if (c == null)
{
count.put(obj, INTEGER_ONE);
}
else
{
count.put(obj, new java.lang.Integer(c.intValue() + 1));
}
}
return count;
}
public bool addAll(java.util.Collection c)
{
JavaIteratorWrapper<dotSesame.Statement> stmtIter = new JavaIteratorWrapper<dotSesame.Statement>(c.iterator());
bool added = false;
foreach (dotSesame.Statement stmt in stmtIter)
{
Triple t = SesameConverter.FromSesame(stmt, this._mapping);
if (!this._g.ContainsTriple(t))
{
this._g.Assert(t);
added = added || true;
}
}
return added;
}
/**
* Finds the first element in the given collection which matches the given predicate.
* <p>
* If the input collection or predicate is null, or no element of the collection
* matches the predicate, null is returned.
*
* @param collection the collection to search, may be null
* @param predicate the predicate to use, may be null
* @return the first element of the collection which matches the predicate or null if none could be found
*/
public static Object find(java.util.Collection<Object> collection, Predicate predicate)
{
if (collection != null && predicate != null)
{
for (java.util.Iterator<Object> iter = collection.iterator(); iter.hasNext(); )
{
Object item = iter.next();
if (predicate.evaluate(item))
{
return item;
}
}
}
return null;
}
/**
* Executes the given closure on each element in the collection.
* <p>
* If the input collection or closure is null, there is no change made.
*
* @param collection the collection to get the input from, may be null
* @param closure the closure to perform, may be null
*/
public static void forAllDo(java.util.Collection<Object> collection, Closure closure)
{
if (collection != null && closure != null)
{
for (java.util.Iterator<Object> it = collection.iterator(); it.hasNext(); )
{
closure.execute(it.next());
}
}
}
/**
* Filter the collection by applying a Predicate to each element. If the
* predicate returns false, remove the element.
* <p>
* If the input collection or predicate is null, there is no change made.
*
* @param collection the collection to get the input from, may be null
* @param predicate the predicate to use as a filter, may be null
*/
public static void filter(java.util.Collection<Object> collection, Predicate predicate)
{
if (collection != null && predicate != null)
{
for (java.util.Iterator<Object> it = collection.iterator(); it.hasNext(); )
{
if (predicate.evaluate(it.next()) == false)
{
it.remove();
}
}
}
}
/**
* Answers true if a predicate is true for at least one element of a collection.
* <p>
* A <code>null</code> collection or predicate returns false.
*
* @param collection the collection to get the input from, may be null
* @param predicate the predicate to use, may be null
* @return true if at least one element of the collection matches the predicate
*/
public static bool exists(java.util.Collection<Object> collection, Predicate predicate)
{
if (collection != null && predicate != null)
{
for (java.util.Iterator<Object> it = collection.iterator(); it.hasNext(); )
{
if (predicate.evaluate(it.next()))
{
return true;
}
}
}
return false;
}
/**
* Counts the number of elements in the input collection that match the predicate.
* <p>
* A <code>null</code> collection or predicate matches no elements.
*
* @param inputCollection the collection to get the input from, may be null
* @param predicate the predicate to use, may be null
* @return the number of matches for the predicate in the collection
*/
public static int countMatches(java.util.Collection<Object> inputCollection, Predicate predicate)
{
int count = 0;
if (inputCollection != null && predicate != null)
{
for (java.util.Iterator<Object> it = inputCollection.iterator(); it.hasNext(); )
{
if (predicate.evaluate(it.next()))
{
count++;
}
}
}
return count;
}
/**
* Returns the number of occurrences of <i>obj</i> in <i>coll</i>.
*
* @param obj the object to find the cardinality of
* @param coll the collection to search
* @return the the number of occurrences of obj in coll
*/
public static int cardinality(Object obj, java.util.Collection<Object> coll)
{
if (coll is java.util.Set<Object>)
{
return (coll.contains(obj) ? 1 : 0);
}
if (coll is Bag)
{
return ((Bag)coll).getCount(obj);
}
int count = 0;
if (obj == null)
{
for (java.util.Iterator<Object> it = coll.iterator(); it.hasNext(); )
{
if (it.next() == null)
{
count++;
}
}
}
else
{
for (java.util.Iterator<Object> it = coll.iterator(); it.hasNext(); )
{
if (obj.equals(it.next()))
{
count++;
}
}
}
return count;
}
/**
* Returns <tt>true</tt> iff <i>a</i> is a sub-collection of <i>b</i>,
* that is, iff the cardinality of <i>e</i> in <i>a</i> is less
* than or equal to the cardinality of <i>e</i> in <i>b</i>,
* for each element <i>e</i> in <i>a</i>.
*
* @param a the first (sub?) collection, must not be null
* @param b the second (super?) collection, must not be null
* @return <code>true</code> iff <i>a</i> is a sub-collection of <i>b</i>
* @see #isProperSubCollection
* @see Collection#containsAll
*/
public static bool isSubCollection(java.util.Collection<Object> a, java.util.Collection<Object> b)
{
java.util.Map<Object, Object> mapa = getCardinalityMap(a);
java.util.Map<Object, Object> mapb = getCardinalityMap(b);
java.util.Iterator<Object> it = a.iterator();
while (it.hasNext())
{
Object obj = it.next();
if (getFreq(obj, mapa) > getFreq(obj, mapb))
{
return false;
}
}
return true;
}
/**
* Create a new Transformer that calls each transformer in turn, passing the
* result into the next transformer. The ordering is that of the iterator()
* method on the collection.
*
* @param transformers a collection of transformers to chain
* @return the <code>chained</code> transformer
* @throws IllegalArgumentException if the transformers collection is null
* @throws IllegalArgumentException if any transformer in the collection is null
*/
public static Transformer getInstance(java.util.Collection<Object> transformers)
{
if (transformers == null)
{
throw new java.lang.IllegalArgumentException("Transformer collection must not be null");
}
if (transformers.size() == 0)
{
return NOPTransformer.INSTANCE;
}
// convert to array like this to guarantee iterator() ordering
Transformer[] cmds = new Transformer[transformers.size()];
int i = 0;
for (java.util.Iterator<Object> it = transformers.iterator(); it.hasNext(); )
{
cmds[i++] = (Transformer)it.next();
}
FunctorUtils.validate(cmds);
return new ChainedTransformer(cmds);
}
//-----------------------------------------------------------------------
/**
* Returns a new list containing all elements that are contained in
* both given lists.
*
* @param list1 the first list
* @param list2 the second list
* @return the intersection of those two lists
* @throws NullPointerException if either list is null
*/
public static java.util.List<Object> intersection(java.util.List<Object> list1, java.util.List<Object> list2)
{
java.util.ArrayList<Object> result = new java.util.ArrayList<Object>();
java.util.Iterator<Object> iterator = list2.iterator();
while (iterator.hasNext())
{
Object o = iterator.next();
if (list1.contains(o))
{
result.add(o);
}
}
return result;
}
public bool containsAll(java.util.Collection c)
{
JavaIteratorWrapper<dotSesame.Statement> stmtIter = new JavaIteratorWrapper<org.openrdf.model.Statement>(c.iterator());
bool contains = true;
foreach (dotSesame.Statement stmt in stmtIter)
{
Triple t = SesameConverter.FromSesame(stmt, this._mapping);
if (!this._g.ContainsTriple(t))
{
contains = false;
break;
}
}
return contains;
}
/**
* Tests two lists for value-equality as per the equality contract in
* {@link java.util.List#equals(java.lang.Object)}.
* <p>
* This method is useful for implementing <code>List</code> when you cannot
* extend AbstractList. The method takes Collection instances to enable other
* collection types to use the List implementation algorithm.
* <p>
* The relevant text (slightly paraphrased as this is a static method) is:
* <blockquote>
* Compares the two list objects for equality. Returns
* <tt>true</tt> if and only if both
* lists have the same size, and all corresponding pairs of elements in
* the two lists are <i>equal</i>. (Two elements <tt>e1</tt> and
* <tt>e2</tt> are <i>equal</i> if <tt>(e1==null ? e2==null :
* e1.equals(e2))</tt>.) In other words, two lists are defined to be
* equal if they contain the same elements in the same order. This
* definition ensures that the equals method works properly across
* different implementations of the <tt>List</tt> interface.
* </blockquote>
*
* <b>Note:</b> The behaviour of this method is undefined if the lists are
* modified during the equals comparison.
*
* @see java.util.List
* @param list1 the first list, may be null
* @param list2 the second list, may be null
* @return whether the lists are equal by value comparison
*/
public static bool isEqualList(java.util.Collection<Object> list1, java.util.Collection<Object> list2)
{
if (list1 == list2)
{
return true;
}
if (list1 == null || list2 == null || list1.size() != list2.size())
{
return false;
}
java.util.Iterator<Object> it1 = list1.iterator();
java.util.Iterator<Object> it2 = list2.iterator();
Object obj1 = null;
Object obj2 = null;
while (it1.hasNext() && it2.hasNext())
{
obj1 = it1.next();
obj2 = it2.next();
if (!(obj1 == null ? obj2 == null : obj1.equals(obj2)))
{
return false;
}
}
return !(it1.hasNext() || it2.hasNext());
}
public bool retainAll(java.util.Collection c)
{
JavaIteratorWrapper<dotSesame.Statement> stmtIter = new JavaIteratorWrapper<org.openrdf.model.Statement>(c.iterator());
HashSet<Triple> retained = new HashSet<Triple>();
bool changed = false;
foreach (dotSesame.Statement stmt in stmtIter)
{
retained.Add(SesameConverter.FromSesame(stmt, this._mapping));
}
foreach (Triple t in this._g.Triples.ToList())
{
if (!retained.Contains(t))
{
changed = true;
this._g.Retract(t);
}
}
return changed;
}
/**
* Removes the elements in <code>remove</code> from <code>collection</code>. That is, this
* method returns a list containing all the elements in <code>c</code>
* that are not in <code>remove</code>. The cardinality of an element <code>e</code>
* in the returned collection is the same as the cardinality of <code>e</code>
* in <code>collection</code> unless <code>remove</code> contains <code>e</code>, in which
* case the cardinality is zero. This method is useful if you do not wish to modify
* <code>collection</code> and thus cannot call <code>collection.removeAll(remove);</code>.
*
* @param collection the collection from which items are removed (in the returned collection)
* @param remove the items to be removed from the returned <code>collection</code>
* @return a <code>List</code> containing all the elements of <code>c</code> except
* any elements that also occur in <code>remove</code>.
* @throws NullPointerException if either parameter is null
* @since Commons Collections 3.2
*/
public static java.util.List<Object> removeAll(java.util.Collection<Object> collection, java.util.Collection<Object> remove)
{
java.util.List<Object> list = new java.util.ArrayList<Object>();
for (java.util.Iterator<Object> iter = collection.iterator(); iter.hasNext(); )
{
Object obj = iter.next();
if (remove.contains(obj) == false)
{
list.add(obj);
}
}
return list;
}
/**
* Validate the predicates to ensure that all is well.
*
* @param predicates the predicates to validate
* @return predicate array
*/
internal static Predicate[] validate(java.util.Collection<Predicate> predicates)
{
if (predicates == null)
{
throw new java.lang.IllegalArgumentException("The predicate collection must not be null");
}
// convert to array like this to guarantee iterator() ordering
Predicate[] preds = new Predicate[predicates.size()];
int i = 0;
for (java.util.Iterator<Predicate> it = predicates.iterator(); it.hasNext(); )
{
preds[i] = it.next();
if (preds[i] == null)
{
throw new java.lang.IllegalArgumentException("The predicate collection must not contain a null predicate, index " + i + " was null");
}
i++;
}
return preds;
}
/**
* Returns a new {@link Collection} containing <tt><i>a</i> - <i>b</i></tt>.
* The cardinality of each element <i>e</i> in the returned {@link Collection}
* will be the cardinality of <i>e</i> in <i>a</i> minus the cardinality
* of <i>e</i> in <i>b</i>, or zero, whichever is greater.
*
* @param a the collection to subtract from, must not be null
* @param b the collection to subtract, must not be null
* @return a new collection with the results
* @see Collection#removeAll
*/
public static java.util.Collection<Object> subtract(java.util.Collection<Object> a, java.util.Collection<Object> b)
{
java.util.ArrayList<Object> list = new java.util.ArrayList<Object>(a);
for (java.util.Iterator<Object> it = b.iterator(); it.hasNext(); )
{
list.remove(it.next());
}
return list;
}
/**
* Generates a hash code using the algorithm specified in
* {@link java.util.Set#hashCode()}.
* <p>
* This method is useful for implementing <code>Set</code> when you cannot
* extend AbstractSet. The method takes Collection instances to enable other
* collection types to use the Set implementation algorithm.
*
* @see java.util.Set#hashCode()
* @param set the set to calculate the hash code for, may be null
* @return the hash code
*/
public static int hashCodeForSet(java.util.Collection<Object> set)
{
if (set == null)
{
return 0;
}
int hashCode = 0;
java.util.Iterator<Object> it = set.iterator();
Object obj = null;
while (it.hasNext())
{
obj = it.next();
if (obj != null)
{
hashCode += obj.GetHashCode();
}
}
return hashCode;
}
/**
* Subtracts all elements in the second list from the first list,
* placing the results in a new list.
* <p>
* This differs from {@link List#removeAll(Collection)} in that
* cardinality is respected; if <Code>list1</Code> contains two
* occurrences of <Code>null</Code> and <Code>list2</Code> only
* contains one occurrence, then the returned list will still contain
* one occurrence.
*
* @param list1 the list to subtract from
* @param list2 the list to subtract
* @return a new list containing the results
* @throws NullPointerException if either list is null
*/
public static java.util.List<Object> subtract(java.util.List<Object> list1, java.util.List<Object> list2)
{
java.util.ArrayList<Object> result = new java.util.ArrayList<Object>(list1);
java.util.Iterator<Object> iterator = list2.iterator();
while (iterator.hasNext())
{
result.remove(iterator.next());
}
return result;
}
//-----------------------------------------------------------------------
/**
* Returns a List containing all the elements in <code>collection</code>
* that are also in <code>retain</code>. The cardinality of an element <code>e</code>
* in the returned list is the same as the cardinality of <code>e</code>
* in <code>collection</code> unless <code>retain</code> does not contain <code>e</code>, in which
* case the cardinality is zero. This method is useful if you do not wish to modify
* the collection <code>c</code> and thus cannot call <code>collection.retainAll(retain);</code>.
*
* @param collection the collection whose contents are the target of the #retailAll operation
* @param retain the collection containing the elements to be retained in the returned collection
* @return a <code>List</code> containing all the elements of <code>c</code>
* that occur at least once in <code>retain</code>.
* @throws NullPointerException if either parameter is null
* @since Commons Collections 3.2
*/
public static java.util.List<Object> retainAll(java.util.Collection<Object> collection, java.util.Collection<Object> retain)
{
java.util.List<Object> list = new java.util.ArrayList<Object>(java.lang.Math.min(collection.size(), retain.size()));
for (java.util.Iterator<Object> iter = collection.iterator(); iter.hasNext(); )
{
Object obj = iter.next();
if (retain.contains(obj))
{
list.add(obj);
}
}
return list;
}
/**
* Transforms all elements from inputCollection with the given transformer
* and adds them to the outputCollection.
* <p>
* If the input collection or transformer is null, there is no change to the
* output collection.
*
* @param inputCollection the collection to get the input from, may be null
* @param transformer the transformer to use, may be null
* @param outputCollection the collection to output into, may not be null
* @return the outputCollection with the transformed input added
* @throws NullPointerException if the output collection is null
*/
public static java.util.Collection<Object> collect(java.util.Collection<Object> inputCollection, Transformer transformer, java.util.Collection<Object> outputCollection)
{
if (inputCollection != null)
{
return collect(inputCollection.iterator(), transformer, outputCollection);
}
return outputCollection;
}