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); }
/// <summary> /// Get a datatable with all tables. /// </summary> public override System.Data.DataTable QueryTables(bool p_all_schemas) { System.Data.DataTable v_table; System.Data.DataRow v_row; v_table = new System.Data.DataTable("Tables"); v_table.Columns.Add("table_name"); com.healthmarketscience.jackcess.Database v_database = com.healthmarketscience.jackcess.DatabaseBuilder.open(new java.io.File(this.v_connection.v_service)); java.util.Set v_set = v_database.getTableNames(); object[] v_obj = v_set.toArray(); foreach (object o in v_obj) { v_row = v_table.NewRow(); if (((string)o).Contains(" ")) { v_row["table_name"] = "[" + (string)o + "]"; } else { v_row["table_name"] = (string)o; } v_table.Rows.Add(v_row); } return(v_table); }
public virtual string buildUnionSubQuery(string typeDiscriminatorColumn, string[] unionColumns, java.util.Set <string> columnsPresentInTable, int computedColumnsOffset , string typeDiscriminatorValue, string selection, string[] selectionArgs, string groupBy, string having) { throw new System.NotImplementedException(); }
/* * Returns an unmodifiable {@code Set} of all services registered by this * provider. * * @return an unmodifiable {@code Set} of all services registered by this * provider */ public java.util.Set <Provider.Service> getServices() { lock (this) { updatePropertyServiceTable(); if (lastServicesSet != null) { return(lastServicesSet); } if (serviceTable != null) { lastServicesSet = new java.util.HashSet <Service>(serviceTable.values()); } else { lastServicesSet = new java.util.HashSet <Service>(); } if (propertyServiceTable != null) { lastServicesSet.addAll(propertyServiceTable.values()); } lastServicesSet = java.util.Collections <Object> .unmodifiableSet(lastServicesSet); return(lastServicesSet); } }
// Map views //----------------------------------------------------------------------- /** * Gets a keySet 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 keySet view */ public virtual java.util.Set <Object> keySet() { if (keySetJ == null) { keySetJ = new KeySet(this); } return(keySetJ); }
/** * Gets an entrySet view of the map. * Changes made on the set are reflected in the map. * The set supports remove and clear but not add. * <p> * The Map Entry setValue() method only allow a new value to be set. * If the value being set is already in the map, an IllegalArgumentException * is thrown (as setValue cannot change the size of the map). * * @return the entrySet view */ public virtual java.util.Set <java.util.MapNS.Entry <Object, Object> > entrySet() { if (entrySetJ == null) { entrySetJ = new EntrySet(this); } return((java.util.Set <java.util.MapNS.Entry <Object, Object> >)entrySetJ); }
/** * Factory method to create an unmodifiable set. * * @param set the set to decorate, must not be null * @throws IllegalArgumentException if set is null */ public static java.util.Set <Object> decorate(java.util.Set <Object> set) { if (set is Unmodifiable) { return(set); } return(new UnmodifiableSet(set)); }
/** * Returns a collection view of the mappings */ public override java.util.Set <java.util.MapNS.Entry <String, V> > entrySet() { if (entrySetJ == null) { entrySetJ = new EntrySetImpl(this); } return(entrySetJ); }
/** * Returns an unmodifiable view of the underlying map's key set. * * @return the set of unique elements in this bag */ public virtual java.util.Set <Object> uniqueSet() { if (uniqueSetJ == null) { uniqueSetJ = UnmodifiableSet.decorate(map.keySet()); } return(uniqueSetJ); }
private java.util.Set <Object> getEntrySet() { if (entrySet == null) { entrySet = parent.getMap().entrySet(); } return((java.util.Set <Object>)entrySet); }
public java.util.Set <Object> uniqueSet() { lock (lockJ) { java.util.Set <Object> set = getBag().uniqueSet(); return(new SynchronizedBagSet(set, lockJ)); } }
//----------------------------------------------------------------------- /** * Constructor that wraps (not copies) the List and specifies the set to use. * <p> * The set and list must both be correctly initialised to the same elements. * * @param set the set to decorate, must not be null * @param list the list to decorate, must not be null * @throws IllegalArgumentException if set or list is null */ protected internal SetUniqueList(java.util.List <Object> list, java.util.Set <Object> set) : base(list) { if (set == null) { throw new java.lang.IllegalArgumentException("Set must not be null"); } this.setJ = set; }
/** * Constructor that wraps (not copies) the Set and specifies the list to use. * <p> * The set and list must both be correctly initialised to the same elements. * * @param set the set to decorate, must not be null * @param list the list to decorate, must not be null * @throws IllegalArgumentException if set or list is null */ protected ListOrderedSet(java.util.Set <Object> set, java.util.List <Object> list) : base(set) { if (list == null) { throw new java.lang.IllegalArgumentException("List must not be null"); } setOrder = list; }
public java.util.Set GetConceptChild(OWLOntology ontology) { if (this.conceptChild == null) { this.conceptChild = GetConcept(ontology).getSubClasses(ontology); } return(this.conceptChild); }
//----------------------------------------------------------------------- /** * Constructor that wraps (not copies) the List and specifies the set to use. * <p> * The set and list must both be correctly initialised to the same elements. * * @param set the set to decorate, must not be null * @param list the list to decorate, must not be null * @throws IllegalArgumentException if set or list is null */ protected internal SetUniqueList(java.util.List<Object> list, java.util.Set<Object> set) : base(list) { if (set == null) { throw new java.lang.IllegalArgumentException("Set must not be null"); } this.setJ = set; }
/* * Prints Services content */ // FIXME remove debug function public static void printServices() { refresh(); java.util.Set <String> s = services.keySet(); for (java.util.Iterator <String> i = s.iterator(); i.hasNext();) { String key = i.next(); java.lang.SystemJ.outJ.println(key + "=" + services.get(key)); //$NON-NLS-1$ } }
public OntologyConcept(string _ConceptKey, string _ConceptName, int _Weigth, OWLClass _Concept, java.util.Set _ConceptParent, java.util.Set _ConceptChild) : this() { this.conceptKey = _ConceptKey; this.conceptValue = _ConceptName; this.weigth = _Weigth; this.concept = _Concept; this.conceptParent = _ConceptParent; this.conceptChild = _ConceptChild; }
/** * Returns a set view of the mappings contained in this map. Each element * in the returned set is a <code>Map.Entry</code>. The set is backed by the * map, so changes to the map are reflected in the set, and vice-versa. * If the map is modified while an iteration over the set is in progress, * the results of the iteration are undefined. The set supports element * removal, which removes the corresponding mapping from the map, via the * <tt>Iterator.remove</tt>, <tt>Set.remove</tt>, <tt>removeAll</tt>, * <tt>retainAll</tt> and <tt>clear</tt> operations. It does not support * the <tt>add</tt> or <tt>addAll</tt> operations. * <p> * This implementation returns a <code>CompositeSet</code> which * composites the entry sets from all of the composited maps. * * @see CompositeSet * @return a set view of the mappings contained in this map. */ public java.util.Set <java.util.MapNS.Entry <Object, Object> > entrySet() { CompositeSet entries = new CompositeSet(); for (int i = this.composite.Length - 1; i >= 0; --i) { java.util.Set <java.util.MapNS.Entry <Object, Object> > e = this.composite[i].entrySet(); entries.addComposited((java.util.Set <Object>)e); } return((java.util.Set <java.util.MapNS.Entry <Object, Object> >)entries); //! ??? no error at call ??? }
int java.text.AttributedCharacterIterator.getRunStart(java.util.Set arg0) { global::MonoJavaBridge.JNIEnv @__env = global::MonoJavaBridge.JNIEnv.ThreadEnv; if (!IsClrObject) { return(@__env.CallIntMethod(this.JvmHandle, global::java.text.AttributedCharacterIterator_._getRunStart15040, global::MonoJavaBridge.JavaBridge.ConvertToValue(arg0))); } else { return(@__env.CallNonVirtualIntMethod(this.JvmHandle, global::java.text.AttributedCharacterIterator_.staticClass, global::java.text.AttributedCharacterIterator_._getRunStart15040, global::MonoJavaBridge.JavaBridge.ConvertToValue(arg0))); } }
/* Set operations */ /** * If a <code>CollectionMutator</code> is defined for this CompositeSet then this * method will be called anyway. * * @param obj Object to be removed * @return true if the object is removed, false otherwise */ public override bool remove(Object obj) { for (java.util.Iterator <Object> i = this.getCollections().iterator(); i.hasNext();) { java.util.Set <Object> set = (java.util.Set <Object>)i.next(); if (set.contains(obj)) { return(set.remove(obj)); } } return(false); }
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 } }
/** * @see Set#equals */ public override bool Equals(Object obj) { if (obj is java.util.Set <Object> ) { java.util.Set <Object> set = (java.util.Set <Object>)obj; if (set.containsAll(this) && set.size() == this.size()) { return(true); } } return(false); }
/** * Construct a token stream filtering the given input using a Set of common * words to create bigrams, case-sensitive if ignoreCase is false (unless Set * is CharArraySet). If <code>commonWords</code> is an instance of * {@link CharArraySet} (true if <code>makeCommonSet()</code> was used to * construct the set) it will be directly used and <code>ignoreCase</code> * will be ignored since <code>CharArraySet</code> directly controls case * sensitivity. * <p/> * If <code>commonWords</code> is not an instance of {@link CharArraySet}, a * new CharArraySet will be constructed and <code>ignoreCase</code> will be * used to specify the case sensitivity of that set. * * @param input TokenStream input in filter chain. * @param commonWords The set of common words. * @param ignoreCase -Ignore case when constructing bigrams for common words. */ public CommonGramsFilter(TokenStream input, Set commonWords, bool ignoreCase) : base(input) { if (commonWords is CharArraySet) { this.commonWords = (CharArraySet)commonWords; } else { this.commonWords = new CharArraySet(commonWords.size(), ignoreCase); this.commonWords.addAll(commonWords); } init(); }
private void getAllUsedPermissions(int sharedUid, java.util.Set <android.content.pm.PermissionInfo > permSet) { string[] sharedPkgList = mPm.getPackagesForUid(sharedUid); if (sharedPkgList == null || (sharedPkgList.Length == 0)) { return; } foreach (string sharedPkg in sharedPkgList) { getPermissionsForPackage(sharedPkg, permSet); } }
/** * 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 void write(string resourceName, Assembly compiledAssembly) * { * * this.assem = compiledAssembly; * wire(resourceName); * }*/ public override void loadAssemblies() { java.util.Set set = this.assemblySerializationInfoStore.keySet(); object[] objs = set.toArray(); BinaryFormatter formatter = new BinaryFormatter(); foreach (object obj in objs) { Assembly assem = (Assembly)formatter.Deserialize(new MemoryStream((byte[]) (this.assemblySerializationInfoStore.get(obj)))); this.store.put(obj, assem); } }
public int getRunStart(java.util.Set <AttributedCharacterIteratorNS.Attribute> attributes) { int start = begin; java.util.Iterator <AttributedCharacterIteratorNS.Attribute> it = attributes.iterator(); while (it.hasNext()) { AttributedCharacterIteratorNS.Attribute attribute = it.next(); int newStart = getRunStart(attribute); if (newStart > start) { start = newStart; } } return(start); }
public int getRunLimit(java.util.Set <AttributedCharacterIteratorNS.Attribute> attributes) { int limit = end; java.util.Iterator <AttributedCharacterIteratorNS.Attribute> it = attributes.iterator(); while (it.hasNext()) { AttributedCharacterIteratorNS.Attribute attribute = it.next(); int newLimit = getRunLimit(attribute); if (newLimit < limit) { limit = newLimit; } } return(limit); }
public java.util.Set GetConceptParents(OWLOntology ontology) { if (this.conceptParent == null) { if (GetConcept(ontology) != null) //Si no es una instancia, obtener la clase { this.conceptParent = GetConcept(ontology).getSuperClasses(ontology); } else { //Es una instancia entonces no tiene padres this.conceptParent = null; } } return(this.conceptParent); }
/** * Factory method to create an ordered set specifying the list and set to use. * <p> * The list and set must both be empty. * * @param set the set to decorate, must be empty and not null * @param list the list to decorate, must be empty and not null * @throws IllegalArgumentException if set or list is null * @throws IllegalArgumentException if either the set or list is not empty * @since Commons Collections 3.1 */ public static ListOrderedSet decorate(java.util.Set <Object> set, java.util.List <Object> list) { if (set == null) { throw new java.lang.IllegalArgumentException("Set must not be null"); } if (list == null) { throw new java.lang.IllegalArgumentException("List must not be null"); } if (set.size() > 0 || list.size() > 0) { throw new java.lang.IllegalArgumentException("Set and List must be empty"); } return(new ListOrderedSet(set, list)); }
private AttributedString(AttributedCharacterIterator iterator, int start, int end, java.util.Set <AttributedCharacterIteratorNS.Attribute> attributes) { if (start < iterator.getBeginIndex() || end > iterator.getEndIndex() || start > end) { throw new java.lang.IllegalArgumentException(); } if (attributes == null) { return; } StringBuilder buffer = new StringBuilder(); iterator.setIndex(start); while (iterator.getIndex() < end) { buffer.Append(iterator.current()); iterator.next(); } text = buffer.ToString(); attributeMap = new java.util.HashMap <AttributedCharacterIteratorNS.Attribute, java.util.List <IAC_Range> >();//(attributes.size() * 4 / 3) + 1); java.util.Iterator <AttributedCharacterIteratorNS.Attribute> it = attributes.iterator(); while (it.hasNext()) { AttributedCharacterIteratorNS.Attribute attribute = it.next(); iterator.setIndex(start); while (iterator.getIndex() < end) { System.Object value = iterator.getAttribute(attribute); int runStart = iterator.getRunStart(attribute); int limit = iterator.getRunLimit(attribute); if ((value is java.lang.annotation.Annotation && runStart >= start && limit <= end) || (value != null && !(value is java.lang.annotation.Annotation))) { addAttribute(attribute, value, (runStart < start ? start : runStart) - start, (limit > end ? end : limit) - start); } iterator.setIndex(limit); } } }
/** * Returns an unmodifiable {@code Set} of all services registered by this * provider. * * @return an unmodifiable {@code Set} of all services registered by this * provider */ public java.util.Set<Provider.Service> getServices() { lock (this) { updatePropertyServiceTable(); if (lastServicesSet != null) { return lastServicesSet; } if (serviceTable != null) { lastServicesSet = new java.util.HashSet<Service>(serviceTable.values()); } else { lastServicesSet = new java.util.HashSet<Service>(); } if (propertyServiceTable != null) { lastServicesSet.addAll(propertyServiceTable.values()); } lastServicesSet = java.util.Collections<Object>.unmodifiableSet(lastServicesSet); return lastServicesSet; } }
private void servicesChanged() { lastServicesByType = null; lastServiceName = null; lastServicesSet = null; }
protected internal SetListListIterator(java.util.ListIterator<Object> it, java.util.Set<Object> set) : base(it) { this.setJ = set; }
protected internal virtual void getCorrespondingTerminalNodes(ViewGraphNode root, Set target) { BaseNode n = root.ReteNode; if (n is TerminalNode) target.add(n); Iterator it = root.childs.iterator(); while (it.hasNext()) { ViewGraphNode succ = (ViewGraphNode) it.next(); getCorrespondingTerminalNodes(succ, target); } }
/// <summary> /// Adds the given assembly to the included set, if and only /// if it is not contained by the encountered set and it /// is not a system assembly; a core HSQLDB assembly; an /// IKVM assembly; an NUnit assembly or a TestDriven.NET /// assembly. /// </summary> /// <remarks> /// The exclusion list could be made much larger to produce /// a higher quality included set, but at what price? /// </remarks> /// <param name="encountered">The assemblies encountered so far.</param> /// <param name="included">The assemblies included so far.</param> /// <param name="entry">The assembly to add.</param> internal static void AddAssembly( Set encountered, Set included, Assembly entry) { if (entry == null || encountered.contains(entry)) { return; } else { encountered.add(entry); } string simpleName = entry.GetName().Name; // ignored (performance optimization) if (simpleName == "System" || simpleName == "mscorlib" || simpleName == "Org.Hsqldb" || simpleName.StartsWith("System.") || simpleName.StartsWith("IKVM.") || simpleName.StartsWith("nunit.") || simpleName.StartsWith("TestDriven.")) { return; } else { included.add(entry); } try { Assembly satellite = entry.GetSatelliteAssembly(CultureInfo.CurrentCulture); IkvmResourceLoaderFactory.AddAssembly( encountered, included, satellite); } catch (Exception ex) { #if DEBUG Debug.WriteLine(ex); #endif } AssemblyName[] referencedAssemblies = entry.GetReferencedAssemblies(); for (int i = 0; i < referencedAssemblies.Length; i++) { AssemblyName assemblyName = referencedAssemblies[i]; try { Assembly referencedAssembly = Assembly.Load(assemblyName); IkvmResourceLoaderFactory.AddAssembly( encountered, included, referencedAssembly); } catch (System.Exception ex) { #if DEBUG Debug.WriteLine(ex); #endif } } }