public bool addAll(int i, java.util.Collection <Object> o) { if (root.fast) { lock (root) { java.util.ArrayList <Object> temp = (java.util.ArrayList <Object>)root.list.clone(); bool r = get(temp).addAll(i, o); root.list = temp; if (r) { last += o.size(); } expected = temp; return(r); } } else { lock (root.list) { return(get(expected).addAll(i, o)); } } }
public bool removeAll(java.util.Collection <Object> o) { if (root.fast) { lock (root) { java.util.ArrayList <Object> temp = (java.util.ArrayList <Object>)root.list.clone(); java.util.List <Object> sub = get(temp); bool r = sub.removeAll(o); if (r) { last = first + sub.size(); } root.list = temp; expected = temp; return(r); } } else { lock (root.list) { return(get(expected).removeAll(o)); } } }
/** * Add an additional Map to the composite. * * @param map the Map to be added to the composite * @throws IllegalArgumentException if there is a key collision and there is no * MapMutator set to handle it. */ public void addComposited(java.util.Map <Object, Object> map) {//throws IllegalArgumentException { lock (this) { for (int i = composite.Length - 1; i >= 0; --i) { java.util.Collection <Object> intersect = CollectionUtils.intersection(this.composite[i].keySet(), map.keySet()); if (intersect.size() != 0) { if (this.mutator == null) { throw new java.lang.IllegalArgumentException("Key collision adding Map to CompositeMap"); } else { this.mutator.resolveCollision(this, this.composite[i], map, intersect); } } } java.util.Map <Object, Object>[] temp = new java.util.Map <Object, Object> [this.composite.Length + 1]; java.lang.SystemJ.arraycopy(this.composite, 0, temp, 0, this.composite.Length); temp[temp.Length - 1] = map; this.composite = temp; } }
public override bool retainAll(java.util.Collection <Object> coll) { bool result = base.retainAll(coll); setJ.retainAll(coll); return(result); }
/** * Constructs a new <code>EnumerationIterator</code> that will remove * elements from the specified collection. * * @param enumeration the enumeration to use * @param collection the collection to remove elements form */ public EnumerationIterator(java.util.Enumeration <Object> enumeration, java.util.Collection <Object> collection) : base() { this.enumeration = enumeration; this.collection = collection; this.last = null; }
private void removeNodeImpl()// throws BackingStoreException { { lock (lockJ) { checkState(); String[] childrenNames = childrenNamesSpi(); for (int i = 0; i < childrenNames.Length; i++) { if (null == cachedNode.get(childrenNames[i])) { AbstractPreferences child = childSpi(childrenNames[i]); cachedNode.put(childrenNames[i], child); } } java.util.Collection <AbstractPreferences> values = cachedNode.values(); AbstractPreferences[] children = values .toArray(new AbstractPreferences[values.size()]); foreach (AbstractPreferences child in children) { child.removeNodeImpl(); } removeNodeSpi(); isRemovedJ = true; parentPref.cachedNode.remove(nodeName); } if (parentPref.nodeChangeListeners.size() > 0) { parentPref.notifyChildRemoved(this); } }
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); }
/** * Removes a collection from the those being decorated in this composite. * * @param coll collection to be removed */ public virtual void removeComposited(java.util.Collection <Object> coll) { java.util.ArrayList <Object> list = new java.util.ArrayList <Object>(this.all.Length); list.addAll(java.util.Arrays <Object> .asList <Object>(this.all)); list.remove(coll); this.all = (java.util.Collection <Object>[])list.toArray(new java.util.Collection <Object> [list.size()]); }
/** * Factory method to create an unmodifiable bounded collection. * <p> * This method is capable of drilling down through up to 1000 other decorators * to find a suitable BoundedCollection. * * @param coll the <code>BoundedCollection</code> to decorate, must not be null * @return a new unmodifiable bounded collection * @throws IllegalArgumentException if bag is null */ public static BoundedCollection decorateUsing(java.util.Collection <Object> coll) { if (coll == null) { throw new java.lang.IllegalArgumentException("The collection must not be null"); } // handle decorators for (int i = 0; i < 1000; i++) { // counter to prevent infinite looping if (coll is BoundedCollection) { break; // normal loop exit } else if (coll is AbstractCollectionDecorator) { coll = ((AbstractCollectionDecorator)coll).collection; } else if (coll is SynchronizedCollection) { coll = ((SynchronizedCollection)coll).collection; } else { break; // normal loop exit } } if (coll is BoundedCollection == false) { throw new java.lang.IllegalArgumentException("The collection is not a bounded collection"); } return(new UnmodifiableBoundedCollection((BoundedCollection)coll)); }
/** * 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 ValuesIterator(Object key, MultiValueMap root) { this.root = root; this.key = key; this.values = root.getCollection(key); this.iterator = values.iterator(); }
/// <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 virtual bool retainAll(java.util.Collection <Object> coll) { lock (lockJ) { return(collection.retainAll(coll)); } }
public bool addAll(int index, java.util.Collection <Object> coll) { lock (lockJ) { return(getList().addAll(index, coll)); } }
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 override bool addAll <_T0>(java.util.Collection <_T0> collection) { lock (this._enclosing) { return(this.addAll(this.size(), collection)); } }
public void runRules(String[] rules, java.lang.Object[] facts) { KnowledgeBase kbase = KnowledgeBaseFactory.newKnowledgeBase(); KnowledgeBuilder kbuilder = KnowledgeBuilderFactory.newKnowledgeBuilder(); for (int i = 0; i < rules.Length; i++) { String ruleFile = rules[i]; Console.WriteLine("Loading file: " + ruleFile); ruleFile = Path.GetFullPath(Path.Combine("rules", ruleFile)); kbuilder.add(ResourceFactory.newFileResource(ruleFile), ResourceType.DRL); } java.util.Collection pkgs = kbuilder.getKnowledgePackages(); kbase.addKnowledgePackages(pkgs); StatefulKnowledgeSession ksession = kbase.newStatefulKnowledgeSession(); for (int i = 0; i < facts.Length; i++) { java.lang.Object fact = facts[i]; //Console.WriteLine("Inserting fact: " + fact); ksession.insert(fact); } ksession.fireAllRules(); }
/** * Constructor that wraps (not copies). * * @param coll the collection to decorate, must not be null * @throws IllegalArgumentException if the collection is null */ protected AbstractCollectionDecorator(java.util.Collection <Object> coll) { if (coll == null) { throw new java.lang.IllegalArgumentException("Collection must not be null"); } this.collection = coll; }
public override bool containsAll <_T0>(java.util.Collection <_T0> collection) { java.util.concurrent.CopyOnWriteArrayList.Slice slice = this.slice; object[] snapshot = this._enclosing.elements; slice.checkConcurrentModification(snapshot); return(java.util.concurrent.CopyOnWriteArrayList <E> .containsAll(collection, snapshot , slice.from, slice.to)); }
/** * Gets a values view of the map. * Changes made on the view are reflected in the map. * The set supports remove and clear but not add. * * @return the values view */ public virtual java.util.Collection <Object> values() { if (valuesJ == null) { valuesJ = new Values(this); } return(valuesJ); }
/** * Factory method to create an unmodifiable collection. * <p> * If the collection passed in is already unmodifiable, it is returned. * * @param coll the collection to decorate, must not be null * @return an unmodifiable collection * @throws IllegalArgumentException if collection is null */ public static java.util.Collection <Object> decorate(java.util.Collection <Object> coll) { if (coll is Unmodifiable) { return(coll); } return(new UnmodifiableCollection(coll)); }
public bool addAll(int index, java.util.Collection <Object> coll) { for (java.util.Iterator <Object> it = coll.iterator(); it.hasNext();) { validate(it.next()); } return(getList().addAll(index, coll)); }
/** * Returns a collection view of the values */ public override java.util.Collection <V> values() { if (valuesJ == null) { valuesJ = new ValuesCollectionImpl(this); } return(valuesJ); }
public override bool addAll(java.util.Collection <Object> c) { lock (lockJ) { timeoutWait(c.size()); return(getBuffer().addAll(c)); } }
/** * Remove any members of the bag that are not in the given * bag, respecting cardinality. * * @param coll the collection to retain * @return true if this call changed the collection */ public virtual bool retainAll(java.util.Collection <Object> coll) { if (coll is Bag) { return(retainAll((Bag)coll)); } return(retainAll(new HashBag(coll))); }
/** * 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)); }
// Looping //----------------------------------------------------------------------- /** * Gets an iterator that loops continuously over the supplied collection. * <p> * The iterator will only stop looping if the remove method is called * enough times to empty the collection, or if the collection is empty * to start with. * * @param coll the collection to iterate over, not null * @return a new looping iterator * @throws NullPointerException if the collection is null */ public static ResettableIterator loopingIterator(java.util.Collection <Object> coll) { if (coll == null) { throw new java.lang.NullPointerException("Collection must not be null"); } return(new LoopingIterator(coll)); }
/** * Constructor that wraps a collection. * <p> * There is no way to reset an Iterator instance without recreating it from * the original source, so the Collection must be passed in. * * @param coll the collection to wrap * @throws NullPointerException if the collection is null */ public LoopingIterator(java.util.Collection <Object> coll) { if (coll == null) { throw new java.lang.NullPointerException("The collection must not be null"); } collection = coll; reset(); }
/** * Checks whether the collection at the specified key contains the value. * * @param value the value to search for * @return true if the map contains the value * @since Commons Collections 3.1 */ public virtual bool containsValue(Object key, Object value) { java.util.Collection <Object> coll = getCollection(key); if (coll == null) { return(false); } return(coll.contains(value)); }
/** * Gets an iterator for the collection mapped to the specified key. * * @param key the key to get an iterator for * @return the iterator of the collection at the key, empty iterator if key not in map * @since Commons Collections 3.1 */ public virtual java.util.Iterator <Object> iterator(Object key) { java.util.Collection <Object> coll = getCollection(key); if (coll == null) { return(EmptyIterator.INSTANCE); } return(coll.iterator()); }
/** * Constructor that wraps a collection. * <p> * There is no way to reset an Iterator instance without recreating it from * the original source, so the Collection must be passed in. * * @param coll the collection to wrap * @throws NullPointerException if the collection is null */ public LoopingIterator(java.util.Collection<Object> coll) { if (coll == null) { throw new java.lang.NullPointerException("The collection must not be null"); } collection = coll; reset(); }