/// <summary>
/// Load the compiled XPath expression to prepare it for execution.
/// </summary>
/// <returns>
/// An <c>XPathSelector</c>. The returned <c>XPathSelector</c> can be used to
/// set up the dynamic context, and then to evaluate the expression.
/// </returns>
public XPathSelector Load()
{
ArrayList declaredVariables = new ArrayList();
JIterator iter = env.iterateExternalVariables();
while (iter.hasNext())
{
JXPathVariable var = (JXPathVariable)iter.next();
declaredVariables.Add(var);
}
return(new XPathSelector(exp, config, declaredVariables));
}
public static IEnumerable <T> toIEnumerable <T>(this java.util.List list)
{
if (list != null)
{
java.util.Iterator itr = list.iterator();
while (itr.hasNext())
{
yield return((T)itr.next());
}
}
}
private java.util.Enumeration <Permission> getNextEnumeration()
{
while (pcIter.hasNext())
{
java.util.Enumeration <Permission> en = ((PermissionCollection)pcIter.next()).elements();
if (en.hasMoreElements())
{
return(en);
}
}
return(null);
}
/// <summary>
/// Get a list of external variables used by the expression. This will include both variables that were explicitly
/// declared to the <c>XPathCompiler</c>, and (if the <c>AllowUndeclaredVariables</c> option was set) variables that
/// are referenced within the expression but not explicitly declared.
/// </summary>
/// <returns>
/// An <c>IEnumerator</c> over the names of the external variables, as instances of <c>QName</c>.
/// </returns>
public IEnumerator <QName> EnumerateExternalVariables2()
{
IList <QName> list = new List <QName>();
JIterator iter = executable.iterateExternalVariables();
while (iter.hasNext())
{
net.sf.saxon.s9api.QName var = (net.sf.saxon.s9api.QName)iter.next();
list.Add(new QName(var));
}
return(list.GetEnumerator());
}
public virtual bool containsAll <_T0>(java.util.Collection <_T0> collection)
{
java.util.Iterator <_T0> it = collection.iterator();
while (it.hasNext())
{
if (!contains(it.next()))
{
return(false);
}
}
return(true);
}
private static ImageCodec CreateWriter(java.util.Iterator iter)
{
if (!iter.hasNext())
{
return(null);
}
ImageCodec imageCodec = new ImageCodec();
imageCodec.NativeWriter = (imageio.ImageWriter)iter.next();
return(imageCodec);
}
/**
* Invokes {@link #add(Object)} for each element in the given collection.
*
* @param coll the collection to add
* @return <code>true</code> if this call changed the bag
*/
public virtual bool addAll(java.util.Collection <Object> coll)
{
bool changed = false;
java.util.Iterator <Object> i = coll.iterator();
while (i.hasNext())
{
bool added = add(i.next());
changed = changed || added;
}
return(changed);
}
internal static void CloseSelector(java.nio.channels.Selector selector)
{
java.util.Set keys = selector.keys();
java.util.Iterator it = keys.iterator();
try
{
selector.close();
}
catch (Exception e)
{
#if DEBUG
Console.WriteLine("Caught exception during CloseSelector selector.close - {0}: {1}\n{2}", e.GetType(), e.Message, e.StackTrace);
#endif
}
while (it.hasNext())
{
java.nio.channels.SelectionKey key = (java.nio.channels.SelectionKey)it.next();
Socket source = (Socket)key.attachment();
key.cancel();
try
{
if (source.Blocking)
{
/*
* A channel must be placed into non-blocking mode before being registered
* with a selector, and may not be returned to blocking mode until it has been
* deregistered. So, I need set the channel back to the blocking mode, if it was
* in blocking mode before select operation
*/
source.Blocking = true;
}
}
catch (Exception be)
{
#if DEBUG
Console.WriteLine("Caught exception during CloseSelector source.Blocking - {0}: {1}\n{2}", be.GetType(), be.Message, be.StackTrace);
#endif
}
}
try
{
selector.close();
}
catch (Exception e)
{
#if DEBUG
Console.WriteLine("Caught exception during CloseSelector selector.close - {0}: {1}\n{2}", e.GetType(), e.Message, e.StackTrace);
#endif
}
}
public ArrayList GetNearestNonRelations(string term)
{
ArrayList list = new ArrayList();
java.util.Iterator it = _kb.getNearestNonRelations(term).iterator();
while (it.hasNext())
{
Term t = new Term(this, it.next().ToString());
list.Add(t);
}
return(list);
}
public virtual object[] toArray()
{
int size_1 = size();
int index = 0;
java.util.Iterator <E> it = iterator();
object[] array = new object[size_1];
while (index < size_1)
{
array[index++] = it.next();
}
return(array);
}
/**
* 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);
}
private System.Object currentValue(java.util.List <IAC_Range> ranges)
{
java.util.Iterator <IAC_Range> it = ranges.iterator();
while (it.hasNext())
{
IAC_Range range = it.next();
if (offset >= range.start && offset < range.end)
{
return(inRange(range) ? range.value : null);
}
}
return(null);
}
public ServiceRegistry(java.util.Iterator <java.lang.Class> categoriesIterator)
{
this.categories = new CategoriesMap(this);
if (null == categoriesIterator)
{
throw new java.lang.IllegalArgumentException("categories iterator should not be NULL");
}
while (categoriesIterator.hasNext())
{
java.lang.Class c = categoriesIterator.next();
categories.addCategory(c);
}
}
/**
* 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();
}
}
}
/// <summary>
/// Get a list of external variables used by the expression. This will include both variables that were explicitly
/// declared to the <c>XPathCompiler</c>, and (if the <c>AllowUndeclaredVariables</c> option was set) variables that
/// are referenced within the expression but not explicitly declared.
/// </summary>
/// <returns>
/// An IEnumerator over the names of the external variables, as instances of <c>QName</c>.</returns>
public IEnumerator EnumerateExternalVariables()
{
ArrayList list = new ArrayList();
JIterator iter = env.iterateExternalVariables();
while (iter.hasNext())
{
JXPathVariable var = (JXPathVariable)iter.next();
JStructuredQName q = var.getVariableQName();
list.Add(new QName(q.getPrefix(), q.getURI(), q.getLocalPart()));
}
return(list.GetEnumerator());
}
/**
* Returns <code>true</code> if the bag contains all elements in
* the given collection, respecting cardinality.
*
* @param other the bag to check against
* @return <code>true</code> if the Bag contains all the collection
*/
bool containsAll(Bag other)
{
bool result = true;
java.util.Iterator <Object> it = other.uniqueSet().iterator();
while (it.hasNext())
{
Object current = it.next();
bool contains = getCount(current) >= other.getCount(current);
result = result && contains;
}
return(result);
}
/**
* 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();
}
public override bool addAll <_T0>(int location, java.util.Collection <_T0> collection
)
{
java.util.ListIterator <E> it = listIterator(location);
java.util.Iterator <_T0> colIt = collection.iterator();
int next = it.nextIndex();
while (colIt.hasNext())
{
it.add(colIt.next());
}
return(next != it.nextIndex());
}
/*
* Sets nextObj to a next provider matching the criterion given by the filter
*/
private void findNext()
{
nextObj = default(E);
while (backend.hasNext())
{
E o = backend.next();
if (filter.filter(o))
{
nextObj = o;
return;
}
}
}
//-----------------------------------------------------------------------
/**
* 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());
}
}
/**
* 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());
}
//-----------------------------------------------------------------------
/**
* 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);
}
//-----------------------------------------------------------------------
/**
* Set nextObject to the next object. If there are no more
* objects then return false. Otherwise, return true.
*/
private bool setNextObject()
{
while (iterator.hasNext())
{
Object obj = iterator.next();
if (predicate.evaluate(obj))
{
nextObject = obj;
nextObjectSet = true;
return(true);
}
}
return(false);
}
public OrderedProviderIterator(java.util.Iterator <Object> it)
{
// find all the nodes that with no incoming edges and
// add them to firstNodes
while (it.hasNext())
{
ProviderNode node = (ProviderNode)it.next();
incomingEdges.put(node, new java.lang.Integer(node.getIncomingEdges()));
if (node.getIncomingEdges() == 0)
{
firstNodes.push(node);
}
}
}
internal void doForget()
{
lock (this)
{
java.util.Iterator <android.app.LoadedApk.ServiceDispatcher.ConnectionInfo> it = mActiveConnections
.values().iterator();
while (it.hasNext())
{
android.app.LoadedApk.ServiceDispatcher.ConnectionInfo ci = it.next();
ci.binder.unlinkToDeath(ci.deathMonitor, 0);
}
mActiveConnections.clear();
}
}
public static List <Phrase> GetClauses(this Tree root, Rhetorica.Sentence sentence = null, string ignore = "", string punctuation = null, AnalyzerOptions options = AnalyzerOptions.None)
{
var phrases = new List <Phrase>();
for (java.util.Iterator i = root.iterator(); i.hasNext();)
{
Tree tree = (Tree)i.next();
var treeLabel = tree.label().value();
var clauseRe = @"^(S|SBAR|SBARQ|SINV|SQ|FRAG)$";
bool isClausal = Regex.IsMatch(treeLabel, clauseRe, RegexOptions.IgnoreCase);
if (isClausal)
{
var current = new Phrase(tree.GetTokens(root, sentence, ignore, punctuation, options));
// If current node matches previous node but for punctuation omission, replace previous with current:
bool omitFalseDuplicatePhrases = options.HasFlag(AnalyzerOptions.OmitFalseDuplicatePhrases);
if (omitFalseDuplicatePhrases)
{
if (phrases.Count > 0)
{
Phrase previous = phrases.Last();
if (previous.EqualExceptPunctuationOmission(current))
{
phrases[phrases.Count - 1] = current;
continue;
}
}
}
if (current.Count == 0)
{
continue;
}
phrases.Add(current);
}
}
if (phrases.Count == 0) // Since 'root' has been identified as a sentence, it should have at least one clause associated with it.
{
var pseudoClauses = root.GetPhrases(sentence, ignore, punctuation, options);
if (pseudoClauses.Count > 0)
{
phrases.Add(pseudoClauses[0]);
}
}
return(phrases);
}
// 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);
}
/// <summary>
/// Retrieve an IEnumerable interface to a Java collection.
/// </summary>
/// <param name="list">Java collection</param>
/// <returns></returns>
public static List <net.sf.mpxj.Task> ToTaskList(this java.util.Collection list)
{
var ret = new List <net.sf.mpxj.Task>();
if (list != null)
{
java.util.Iterator itr = list.iterator();
while (itr.hasNext())
{
ret.Add((net.sf.mpxj.Task)itr.next());
}
}
return(ret);
}
/// <summary>
/// Retrieve all the senses that contain this word
/// </summary>
public static Hashtable GetSensesFromWord(string word)
{
java.util.TreeMap tmap = _wn.getSensesFromWord(word);
java.util.Iterator it = tmap.keySet().iterator();
Hashtable table = new Hashtable();
while (it.hasNext())
{
string key = (string)it.next();
java.util.ArrayList jlist = (java.util.ArrayList)tmap.get(key);
table.Add(key, HelperUtils.ToArrayList(jlist));
}
return(table);
}
//-----------------------------------------------------------------------
/**
* 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);
}
