void WriteGraph(RdfGraph graph, RdfSourceWrapper sourcewrapper, StatementSink sink) { java.util.Iterator iter = graph.iterator(); while (iter.hasNext()) { GraphStatement stmt = (GraphStatement)iter.next(); Statement s; if (stmt is GraphStatementWrapper) { s = ((GraphStatementWrapper)stmt).s; } else { s = new Statement( sourcewrapper.ToEntity(stmt.getSubject()), sourcewrapper.ToEntity(stmt.getPredicate()), sourcewrapper.ToResource(stmt.getObject()), stmt.getGraphName() == null ? Statement.DefaultMeta : sourcewrapper.ToEntity(stmt.getGraphName())); } if (s.AnyNull) { continue; // unbound variable, or literal in bad position } sink.Add(s); } }
/** * 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); }
/** * Returns an object array, populating the supplied array if possible. * See <code>Collection</code> interface for full details. * * @param array the array to use, populating if possible * @return an array of all the elements in the collection */ public virtual Object[] toArray <Object>(Object[] array) { int size = this.size(); Object[] result = null; if (array.Length >= size) { result = array; } else { result = new Object[size];// (Object[]) Array.newInstance(array.getClass().getComponentType(), size); } int offset = 0; for (int i = 0; i < this.all.Length; ++i) { for (java.util.Iterator <Object> it = ((java.util.Iterator <Object>) this.all[i].iterator()); it.hasNext();) { result[offset++] = it.next(); } } if (result.Length > size) { result[size] = default(Object); } return(result); }
/** * Tries to find a driver that can interpret the supplied URL. * * @param url * the URL of a database. * @return a {@code Driver} that matches the provided URL. {@code null} if * no {@code Driver} understands the URL * @throws SQLException * if there is any kind of problem accessing the database. */ public static Driver getDriver(String url) { //throws SQLException { java.lang.ClassLoader callerClassLoader = java.lang.Runtime.getRuntime().getClass().getClassLoader(); // Basties note: sometime do the same as VM.callerClassLoader(); lock (theDrivers) { /* * Loop over the drivers in the DriverSet checking to see if one * does understand the supplied URL - return the first driver which * does understand the URL */ java.util.Iterator <Driver> theIterator = theDrivers.iterator(); while (theIterator.hasNext()) { Driver theDriver = theIterator.next(); if (theDriver.acceptsURL(url) && DriverManager.isClassFromClassLoader(theDriver, callerClassLoader)) { return(theDriver); } } } // If no drivers understand the URL, throw an SQLException // sql.6=No suitable driver // SQLState: 08 - connection exception // 001 - SQL-client unable to establish SQL-connection throw new SQLException("No suitable driver", "08001"); //$NON-NLS-1$ //$NON-NLS-2$ }
public SynsetCollection() { _synsets = new java.util.ArrayList(); _synsets.addAll(SUMO.WordNet.Intern.nounSUMOHash.keySet()); java.util.Iterator it = SUMO.WordNet.Intern.verbSUMOHash.keySet().iterator(); while(it.hasNext()) { string s = it.next().ToString(); if(_synsets.contains(s)) continue; _synsets.add(s); } it = SUMO.WordNet.Intern.adjectiveSUMOHash.keySet().iterator(); while(it.hasNext()) { string s = it.next().ToString(); if(_synsets.contains(s)) continue; _synsets.add(s); } it = SUMO.WordNet.Intern.adverbSUMOHash.keySet().iterator(); while(it.hasNext()) { string s = it.next().ToString(); if(_synsets.contains(s)) continue; _synsets.add(s); } _it = _synsets.iterator(); }
/** * 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 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 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); }
public void registerServiceProviders(java.util.Iterator <Object> providers) { for (java.util.Iterator <Object> iterator = providers; iterator.hasNext();) { categories.addProvider(iterator.next(), null); } }
/** * Destroys all instances in the stack and clears the stack. * * @param key key passed to factory when destroying instances * @param stack stack to destroy */ private void destroyStack(K key, java.util.Stack <V> stack) { lock (this) { if (null == stack) { return; } else { if (null != _factory) { java.util.Iterator <V> it = stack.iterator(); while (it.hasNext()) { try { _factory.destroyObject(key, it.next()); } catch (Exception e) { // ignore error, keep destroying the rest } } } _totIdle -= stack.size(); _activeCount.remove(key); stack.clear(); } } }
public Object next() { if (firstNodes.empty()) { throw new java.util.NoSuchElementException(); } // get a node from firstNodes ProviderNode node = firstNodes.pop(); // find all the outgoing nodes java.util.Iterator <Object> it = node.getOutgoingNodes(); while (it.hasNext()) { ProviderNode outNode = (ProviderNode)it.next(); // remove the incoming edge from the node. int edges = incomingEdges.get(outNode); edges--; incomingEdges.put(outNode, new java.lang.Integer(edges)); // add to the firstNodes if this node's incoming edge is equal to 0 if (edges == 0) { firstNodes.push(outNode); } } incomingEdges.remove(node); return(node.getProvider()); }
//----------------------------------------------------------------------- /** * 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()); }
/** * 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)); }
/** * * Adds information about provider services into HashMap. * * @param p */ public static void initServiceInfo(java.security.Provider p) { java.security.Provider.Service serv; String key; String type; String alias; java.lang.StringBuilder sb = new java.lang.StringBuilder(128); for (java.util.Iterator <java.security.Provider.Service> it1 = p.getServices().iterator(); it1.hasNext();) { serv = it1.next(); type = serv.getType(); sb.delete(0, sb.length()); key = sb.append(type).append(".").append( //$NON-NLS-1$ Util.toUpperCase(serv.getAlgorithm())).toString(); if (!services.containsKey(key)) { services.put(key, serv); } for (java.util.Iterator <String> it2 = Engine.door.getAliases(serv); it2.hasNext();) { alias = it2.next(); sb.delete(0, sb.length()); key = sb.append(type).append(".").append(Util.toUpperCase(alias)) //$NON-NLS-1$ .toString(); if (!services.containsKey(key)) { services.put(key, serv); } } } }
static void Main() { java.util.ArrayList <int> primeNumbers = new java.util.ArrayList <int>(); primeNumbers.add(1); primeNumbers.add(2); primeNumbers.add(3); primeNumbers.add(5); primeNumbers.add(7); java.lang.SystemJ.outJ.println("Work with all collection elements"); java.lang.SystemJ.outJ.println("Using collection with for loop"); for (int i = 0; i < primeNumbers.size(); i++) { java.lang.SystemJ.outJ.println(primeNumbers.get(i)); } java.lang.SystemJ.outJ.println("Using collection with iterator while loop"); java.util.Iterator <int> it = primeNumbers.iterator(); while (it.hasNext()) { java.lang.SystemJ.outJ.println(it.next()); } java.lang.SystemJ.outJ.println("Using Java collection with .NET foreach loop"); foreach (int prime in primeNumbers) { java.lang.SystemJ.outJ.println(prime); } java.lang.SystemJ.outJ.print(""); }
public BagIterator(DefaultMapBag parent, java.util.Iterator <Object> support) { _parent = parent; _support = support; _current = null; _mods = parent.modCount(); }
public WordCollection(Synset synset, SpeechTypes type) { _synset = synset; _words = (java.util.ArrayList)SUMO.WordNet.Intern.synsetsToWords.get((int)type + _synset.ID); if(_words == null) _words = new java.util.ArrayList(); _it = _words.iterator(); }
public override string ToString() { if (isEmpty()) { return("[]"); } java.lang.StringBuilder buffer = new java.lang.StringBuilder(size() * 16); buffer.append('['); java.util.Iterator <E> it = iterator(); while (it.hasNext()) { object next = it.next(); if (next != this) { buffer.append(next); } else { buffer.append("(this Collection)"); } if (it.hasNext()) { buffer.append(", "); } } buffer.append(']'); return(buffer.ToString()); }
/** * 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)); }
public override String ToString() { if (size() == 0) { return("[]"); } java.lang.StringBuffer buf = new java.lang.StringBuffer(16 * size()); buf.append("["); java.util.Iterator <Object> it = iterator(); bool hasNext = it.hasNext(); while (hasNext) { Object value = it.next(); buf.append(value == this ? "(this Collection)" : value); hasNext = it.hasNext(); if (hasNext) { buf.append(", "); } } buf.append("]"); return(buf.toString()); }
public ValuesIterator(Object key, MultiValueMap root) { this.root = root; this.key = key; this.values = root.getCollection(key); this.iterator = values.iterator(); }
/** * Returns an {@code Enumeration} that contains all of the loaded JDBC * drivers that the current caller can access. * * @return An {@code Enumeration} containing all the currently loaded JDBC * {@code Drivers}. */ public static java.util.Enumeration <Driver> getDrivers() { java.lang.ClassLoader callerClassLoader = java.lang.Runtime.getRuntime().getClass().getClassLoader();// Basties note: sometime do the same as VM.callerClassLoader(); /* * Synchronize to avoid clashes with additions and removals of drivers * in the DriverSet */ lock (theDrivers) { /* * Create the Enumeration by building a Vector from the elements of * the DriverSet */ java.util.Vector <Driver> theVector = new java.util.Vector <Driver>(); java.util.Iterator <Driver> theIterator = theDrivers.iterator(); while (theIterator.hasNext()) { Driver theDriver = theIterator.next(); if (DriverManager.isClassFromClassLoader(theDriver, callerClassLoader)) { theVector.add(theDriver); } } return(theVector.elements()); } }
/** * Clears any objects sitting idle in the pool. */ public override void clear() { lock (this) { if (null != _factory) { java.util.Iterator <java.lang.refj.SoftReference <T> > iter = _pool.iterator(); while (iter.hasNext()) { try { T obj = iter.next().get(); if (null != obj) { _factory.destroyObject(obj); } } catch (Exception e) { // ignore error, keep destroying the rest } } } _pool.clear(); pruneClearedReferences(); } }
/** * Return the hash code value for this map. This implementation uses * exactly the code that is used to define the list hash function in the * documentation for the <code>Map.hashCode</code> method. * * @return a suitable integer hash code */ public override int GetHashCode() { if (fast) { int h = 0; java.util.Iterator <java.util.MapNS.Entry <Object, Object> > i = map.entrySet().iterator(); while (i.hasNext()) { h += i.next().GetHashCode(); } return(h); } else { lock (map) { int h = 0; java.util.Iterator <java.util.MapNS.Entry <Object, Object> > i = map.entrySet().iterator(); while (i.hasNext()) { h += i.next().GetHashCode(); } return(h); } } }
/// <summary> /// https://universaldependencies.org/u/dep/index.html /// Stratify a sentence according to the subject-predicate relationship /// </summary> /// <param name="sentence"></param> /// <returns>sentence, subject, predicate, objective</returns> public List <(edu.stanford.nlp.util.CoreMap, edu.stanford.nlp.ling.IndexedWord, edu.stanford.nlp.ling.IndexedWord, edu.stanford.nlp.ling.IndexedWord)> StepSamplingDependency(edu.stanford.nlp.util.CoreMap sentence) { List <(edu.stanford.nlp.util.CoreMap, edu.stanford.nlp.ling.IndexedWord, edu.stanford.nlp.ling.IndexedWord, edu.stanford.nlp.ling.IndexedWord)> samplings = new List <(edu.stanford.nlp.util.CoreMap, edu.stanford.nlp.ling.IndexedWord, edu.stanford.nlp.ling.IndexedWord, edu.stanford.nlp.ling.IndexedWord)>(); edu.stanford.nlp.semgraph.SemanticGraph dependencies = sentence.get(enhancedPlusPlusDependenciesAnnotationClass) as edu.stanford.nlp.semgraph.SemanticGraph; java.util.Collection typedDependencies = dependencies.typedDependencies(); java.util.Iterator itr = typedDependencies.iterator(); while (itr.hasNext()) { edu.stanford.nlp.trees.TypedDependency td = itr.next() as edu.stanford.nlp.trees.TypedDependency; string relationType = td.reln().getShortName(); //Nominals if (relationType == "nsubj" || relationType == "nsubjpass") { edu.stanford.nlp.ling.IndexedWord subject, predicate, objective; subject = td.dep(); predicate = td.gov(); //在谓语位置上,缺不满足谓语角色的词,此种谓语可缺省 edu.stanford.nlp.ling.IndexedWord expl = FindIndexedWordByDependencyType(dependencies, predicate, "expl"); predicate = expl == null ? predicate : null; //直接宾语, objective = FindIndexedWordByDependencyType(dependencies, predicate, "obj", "dobj"); //动词或形容词的补语做宾语, open clausal complement objective = objective ?? FindIndexedWordByDependencyType(dependencies, predicate, "ccomp", "xcomp"); //加入层次集合 samplings.Add((sentence, subject, predicate, objective)); } } return(samplings); }
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); }
/** * Returns true if the given object is not null, has the precise type * of this bag, and contains the same number of occurrences of all the * same elements. * * @param object the object to test for equality * @return true if that object equals this bag */ public override bool Equals(Object obj) { if (obj == this) { return(true); } if (obj is Bag == false) { return(false); } Bag other = (Bag)obj; if (other.size() != size()) { return(false); } for (java.util.Iterator <Object> it = _map.keySet().iterator(); it.hasNext();) { Object element = it.next(); if (other.getCount(element) != getCount(element)) { return(false); } } return(true); }
/** * Return the hash code value for this list. This implementation uses * exactly the code that is used to define the list hash function in the * documentation for the <code>List.hashCode</code> method. */ public override int GetHashCode() { if (fast) { int hashCode = 1; java.util.Iterator <Object> i = list.iterator(); while (i.hasNext()) { Object o = i.next(); hashCode = 31 * hashCode + (o == null ? 0 : o.GetHashCode()); } return(hashCode); } else { lock (list) { int hashCode = 1; java.util.Iterator <Object> i = list.iterator(); while (i.hasNext()) { Object o = i.next(); hashCode = 31 * hashCode + (o == null ? 0 : o.GetHashCode()); } return(hashCode); } } }
/** * Remove any members of the bag that are not in the given * bag, respecting cardinality. * @see #retainAll(Collection) * * @param other the bag to retain * @return <code>true</code> if this call changed the collection */ public virtual bool retainAll(Bag other) { bool result = false; Bag excess = new HashBag(); java.util.Iterator <Object> i = uniqueSet().iterator(); while (i.hasNext()) { Object current = i.next(); int myCount = getCount(current); int otherCount = other.getCount(current); if (1 <= otherCount && otherCount <= myCount) { excess.add(current, myCount - otherCount); } else { excess.add(current, myCount); } } if (!excess.isEmpty()) { result = removeAll(excess); } return(result); }
/** * 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); }
public override bool Equals(Object o) { if (!(o is java.util.Map <Object, Object>)) { return(false); } java.util.Map <Object, Object> m = (java.util.Map <Object, Object>)o; java.util.Set <Object> keys = keySet(); if (!keys.equals(m.keySet())) { return(false); } java.util.Iterator <Object> it = keys.iterator(); while (it.hasNext()) { Key key = (Key)it.next(); Object v1 = get(key); Object v2 = m.get(key); if (!(v1 == null?v2 == null:v1.equals(v2))) { return(false); } } return(true); }
/** * 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 WordCollection(Synset synset) { _synset = synset; _words = new java.util.ArrayList(); java.util.ArrayList nouns = (java.util.ArrayList)SUMO.WordNet.Intern.synsetsToWords.get((int)SpeechTypes.Noun + _synset.ID); java.util.ArrayList verbs = (java.util.ArrayList)SUMO.WordNet.Intern.synsetsToWords.get((int)SpeechTypes.Verb + _synset.ID); java.util.ArrayList adjs = (java.util.ArrayList)SUMO.WordNet.Intern.synsetsToWords.get((int)SpeechTypes.Adjective + _synset.ID); java.util.ArrayList advs = (java.util.ArrayList)SUMO.WordNet.Intern.synsetsToWords.get((int)SpeechTypes.Adverb + _synset.ID); if(nouns != null) _words.addAll(nouns); if(verbs != null) _words.addAll(verbs); if(adjs != null) _words.addAll(adjs); if(advs != null) _words.addAll(advs); _it = _words.iterator(); }
public AxiomCollection(KnowledgeBase kb) { _kb = kb; _it = _kb.Intern.formulaMap.keySet().iterator(); }
// Constructor //------------------------------------------------------------------------- /** * Constructs a new <code>ListIteratorWrapper</code> that will wrap * the given iterator. * * @param iterator the iterator to wrap * @throws NullPointerException if the iterator is null */ public ListIteratorWrapper(java.util.Iterator<Object> iterator) : base() { if (iterator == null) { throw new java.lang.NullPointerException("Iterator must not be null"); } this.iterator = iterator; }
public void Reset() { _it = _kb.Intern.collectPredicates().iterator(); }
public PredicateCollection(KnowledgeBase kb) { _kb = kb; _it = _kb.Intern.collectPredicates().iterator(); }
public void Reset() { _it = _mgr.getKBnames().iterator(); }
public TermCollection(KnowledgeBase kb) { _kb = kb; _it = _kb.Intern.terms.iterator(); }
/** * Resets the iterator back to the start of the collection. */ public void reset() { iterator = collection.iterator(); }
public void Reset() { _it = _synsets.iterator(); }
public void Reset() { _it = _words.iterator(); }
//----------------------------------------------------------------------- /** * Resets the state of the iterator. */ public void reset() { iterator = (java.util.Iterator<Object>)map.entrySet().iterator(); last = null; canRemove = false; }
/** * Constructor. * * @param map the map to iterate over */ public EntrySetMapIterator(java.util.Map<Object, Object> map) : base() { this.map = map; this.iterator = (java.util.Iterator<Object>)map.entrySet().iterator(); }
public void Reset() { _it = _kb.Intern.constituents.iterator(); }
public void Reset() { _it = _formula.Intern.getClauses().iterator(); }
public void Reset() { _it = _kb.Intern.formulaMap.keySet().iterator(); }
public ClauseCollection(Formula formula) { _formula = formula; _it = _formula.Intern.getClauses().iterator(); }
public KnowledgeBaseCollection() { _mgr = KBmanager.getMgr(); _it = _mgr.getKBnames().iterator(); }
public ConstituentCollection(KnowledgeBase kb) { _kb = kb; _it = _kb.Intern.constituents.iterator(); }
public void Reset() { _it = _kb.Intern.terms.iterator(); }