/* * Creates an SQLClientInfoException object. The Reason string is set to * reason, the SQLState string is set to the sqlState, the Error Code is set * to the vendorCode the cause Throwable object is set to the given cause * Throwable object, and the Map<String,ClientInfoStatus> object is set to * the failed properties. * * @param reason * the string to use as the Reason string * @param sqlState * the string to use as the SQLState string * @param vendorCode * the integer value for the error code * @param failedProperties * the Map<String,ClientInfoStatus> object to use as the * property values * @param cause * the Throwable object for the underlying reason this * SQLException */ public SQLClientInfoException(String reason, String sqlState, int vendorCode, java.util.Map <String, ClientInfoStatus> failedProperties, java.lang.Throwable cause) : base(reason, sqlState, vendorCode, cause) { this.failedProperties = failedProperties; }
public abstract void bindApplication(string arg1, android.content.pm.ApplicationInfo arg2, java.util.List <android.content.pm.ProviderInfo> arg3, android.content.ComponentName arg4, string arg5, android.os.ParcelFileDescriptor arg6, bool arg7, android.os.Bundle arg8, android.app.IInstrumentationWatcher arg9, int arg10, bool arg11, bool arg12 , android.content.res.Configuration arg13, android.content.res.CompatibilityInfo arg14, java.util.Map <string, android.os.IBinder> arg15, android.os.Bundle arg16 );
/** * Constructs an {@code AttributedString} from an {@code * AttributedCharacterIterator}, which represents attributed text. * * @param iterator * the {@code AttributedCharacterIterator} that contains the text * for this attributed string. */ public AttributedString(AttributedCharacterIterator iterator) { if (iterator.getBeginIndex() > iterator.getEndIndex()) { // text.0A=Invalid substring range throw new java.lang.IllegalArgumentException("Invalid substring range"); //$NON-NLS-1$ } StringBuilder buffer = new StringBuilder(); for (int i = iterator.getBeginIndex(); i < iterator.getEndIndex(); i++) { buffer.Append(iterator.current()); iterator.next(); } text = buffer.ToString(); java.util.Set<AttributedCharacterIteratorNS.Attribute> attributes = iterator .getAllAttributeKeys(); if (attributes == null) { return; } 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(0); while (iterator.current() != CharacterIteratorConstants.DONE) { int start = iterator.getRunStart(attribute); int limit = iterator.getRunLimit(attribute); System.Object value = iterator.getAttribute(attribute); if (value != null) { addAttribute(attribute, value, start, limit); } iterator.setIndex(limit); } } }
public RenderingHints(java.util.Map <Key, Object> map) : base() { if (map != null) { putAll((java.util.Map <Object, Object>)map); } }
/** * Constructs a map that decorates the specified maps, * used by the subclass <code>createBidiMap</code> implementation. * * @param normalMap the normal direction map * @param reverseMap the reverse direction map * @param inverseBidiMap the inverse BidiMap */ protected AbstractDualBidiMap(java.util.Map <Object, Object> normalMap, java.util.Map <Object, Object> reverseMap, BidiMap inverseBidiMap) : base() { maps[0] = normalMap; maps[1] = reverseMap; this.inverseBidiMapJ = inverseBidiMap; }
/** * 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 CollectionViewIterator(CollectionView view) { this.root = view.root; this.view = view; this.expected = root.map; this.iterator = expected.entrySet().iterator(); }
//throws IOException { /** * Opens the given file for reading, assuming the specified * encoding for file names. * * @param f the archive. * @param encoding the encoding to use for file names, use null * for the platform's default encoding * @param useUnicodeExtraFields whether to use InfoZIP Unicode * Extra Fields (if present) to set the file names. * * @throws IOException if an error occurs while reading the file. */ public ZipFile(java.io.File f, String encoding, bool useUnicodeExtraFields) //throws IOException { this.OFFSET_COMPARATOR = new IAC_OFFSET_COMPARATOR(this); this.encoding = encoding; this.zipEncoding = ZipEncodingHelper.getZipEncoding(encoding); this.useUnicodeExtraFields = useUnicodeExtraFields; archive = new java.io.RandomAccessFile(f, "r"); bool success = false; try { java.util.Map <ZipArchiveEntry, IAC_NameAndComment> entriesWithoutUTF8Flag = populateFromCentralDirectory(); resolveLocalFileHeaderData(entriesWithoutUTF8Flag); success = true; } finally { if (!success) { try { archive.close(); } catch (java.io.IOException) { // swallow, throw the original exception instead } } } }
/** * 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)); }
public void remove() { if (lastReturned == null) { throw new java.lang.IllegalStateException(); } if (root.fast) { lock (root) { if (expected != root.map) { throw new java.util.ConcurrentModificationException(); } root.remove(lastReturned.getKey()); lastReturned = null; expected = root.map; } } else { iterator.remove(); lastReturned = null; } }
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); }
/** * 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)); }
/** * Utility method for implementations to set the map that backs * this bag. Not intended for interactive use outside of * subclasses. */ protected virtual void setMap(java.util.Map <Object, Object> map) { if (map == null || map.isEmpty() == false) { throw new java.lang.IllegalArgumentException("The map must be non-null and empty"); } _map = map; }
public override void putAll(java.util.Map <Object, Object> map) { for (java.util.Iterator <java.util.MapNS.Entry <Object, Object> > it = map.entrySet().iterator(); it.hasNext();) { java.util.MapNS.Entry <Object, Object> entry = it.next(); put(entry.getKey(), entry.getValue()); } }
/** * Constructor that wraps (not copies). * * @param map the map to decorate, must not be null * @throws IllegalArgumentException if the collection is null */ public AbstractMapDecorator(java.util.Map <Object, Object> map) { if (map == null) { throw new java.lang.IllegalArgumentException("Map must not be null"); } this.map = map; }
/** * Factory method to create a typed map. * <p> * If there are any elements already in the map being decorated, they * are validated. * * @param map the map to decorate, must not be null * @param keyType the type to allow as keys, must not be null * @param valueType the type to allow as values, must not be null * @throws IllegalArgumentException if list or type is null * @throws IllegalArgumentException if the list contains invalid elements */ public static java.util.Map <Object, Object> decorate(java.util.Map <Object, Object> map, java.lang.Class keyType, java.lang.Class valueType) { return(new PredicatedMap( map, InstanceofPredicate.getInstance(keyType), InstanceofPredicate.getInstance(valueType) )); }
/* * Creates an <code>XPathType</code> instance with the specified XPath * expression, filter, and namespace map. The map is copied to protect * against subsequent modification. * * @param expression the XPath expression to be evaluated * @param filter the filter operation ({@link Filter#INTERSECT}, * {@link Filter#SUBTRACT}, or {@link Filter#UNION}) * @param namespaceMap the map of namespace prefixes. Each key is a * namespace prefix <code>String</code> that maps to a corresponding * namespace URI <code>String</code>. * @throws NullPointerException if <code>expression</code>, * <code>filter</code> or <code>namespaceMap</code> are * <code>null</code> * @throws ClassCastException if any of the map's keys or entries are * not of type <code>String</code> */ public XPathType(String expression, Filter filter, java.util.Map<String,String> namespaceMap) : this(expression, filter){ if (namespaceMap == null) { throw new java.lang.NullPointerException("namespaceMap cannot be null"); } nsMap = unmodifiableCopyOfMap(namespaceMap); // generic using Map<String,String> also remove String checking }
//----------------------------------------------------------------------- /** * Factory method to create a defaulting map. * <p> * The value specified is returned when a missing key is found. * * @param map the map to decorate, must not be null * @param defaultValue the default value to return when the key is not found * @throws IllegalArgumentException if map is null */ public static java.util.Map <Object, Object> decorate(java.util.Map <Object, Object> map, Object defaultValue) { if (defaultValue is Transformer) { defaultValue = ConstantTransformer.getInstance(defaultValue); } return(new DefaultedMap(map, defaultValue)); }
private void readObject(java.io.ObjectInputStream inJ) {//throws IOException, ClassNotFoundException { inJ.defaultReadObject(); maps[0] = new java.util.TreeMap <Object, Object>(comparatorJ); maps[1] = new java.util.TreeMap <Object, Object>(comparatorJ); java.util.Map <Object, Object> map = (java.util.Map <Object, Object>)inJ.readObject(); putAll(map); }
/** * Factory to create the transformer. * <p> * If the map is null, a transformer that always returns null is returned. * * @param map the map, not cloned * @return the transformer */ public static Transformer getInstance(java.util.Map <Object, Object> map) { if (map == null) { return(ConstantTransformer.NULL_INSTANCE); } return(new MapTransformer(map)); }
public void add(Token token, int docFreq) { if (tokenFrequency == null) { tokenFrequency = new LinkedHashMap/*<Token, Integer>*/ (); } tokenFrequency.put(token, docFreq); }
/** * Factory method to create a set from a map. * * @param map the map to decorate, must not be null * @param dummyValue the dummy value to use * @throws IllegalArgumentException if map is null */ public static java.util.Set <Object> decorate(java.util.Map <Object, Object> map, Object dummyValue) { if (map == null) { throw new java.lang.IllegalArgumentException("The map must not be null"); } return(new MapBackedSet(map, dummyValue)); }
public virtual void putAll(java.util.Map <Object, Object> map) { for (java.util.Iterator <Object> it = (java.util.Iterator <Object>)map.entrySet().iterator(); it.hasNext();) { biz.ritter.javapi.util.MapNS.Entry <Object, Object> entry = (biz.ritter.javapi.util.MapNS.Entry <Object, Object>)it.next(); put(entry.getKey(), entry.getValue()); } }
/** * Factory method to create a defaulting map. * <p> * The factory specified is called when a missing key is found. * The result will be returned as the result of the map get(key) method. * * @param map the map to decorate, must not be null * @param factory the factory to use, must not be null * @throws IllegalArgumentException if map or factory is null */ public static java.util.Map <Object, Object> decorate(java.util.Map <Object, Object> map, Factory factory) { if (factory == null) { throw new java.lang.IllegalArgumentException("Factory must not be null"); } return(new DefaultedMap(map, FactoryTransformer.getInstance(factory))); }
/** * Copies all of the mappings from the specified map to this map * (optional operation). The effect of this call is equivalent to that * of calling {@link #put(Object,Object) put(k, v)} on this map once * for each mapping from key <tt>k</tt> to value <tt>v</tt> in the * specified map. The behavior of this operation is unspecified if the * specified map is modified while the operation is in progress. * * @param map Mappings to be stored in this map. * * @throws UnsupportedOperationException if the <tt>putAll</tt> method is * not supported by this map. * * @throws ClassCastException if the class of a key or value in the * specified map prevents it from being stored in this map. * * @throws IllegalArgumentException some aspect of a key or value in the * specified map prevents it from being stored in this map. * @throws NullPointerException the specified map is <tt>null</tt>, or if * this map does not permit <tt>null</tt> keys or values, and the * specified map contains <tt>null</tt> keys or values. */ public void putAll(java.util.Map <Object, Object> map) { if (this.mutator == null) { throw new java.lang.UnsupportedOperationException("No mutator specified"); } this.mutator.putAll(this, this.composite, map); }
static ExtraFieldUtils() { implementations = new java.util.HashMap <Object, Object>(); register(typeof(AsiExtraField)); register(typeof(JarMarker)); register(typeof(UnicodePathExtraField)); register(typeof(UnicodeCommentExtraField)); }
/** * Factory method to create an unmodifiable map. * * @param map the map to decorate, must not be null * @throws IllegalArgumentException if map is null */ public static java.util.Map <Object, Object> decorate(java.util.Map <Object, Object> map) { if (map is Unmodifiable) { return(map); } return(new UnmodifiableMap(map)); }
internal override android.widget.Filter.FilterResults performFiltering(java.lang.CharSequence prefix) { android.widget.Filter.FilterResults results = new android.widget.Filter.FilterResults (); if (this._enclosing.mUnfilteredData == null) { this._enclosing.mUnfilteredData = new java.util.ArrayList <java.util.Map <string, object > >(this._enclosing.mData); } if (prefix == null || prefix.Length == 0) { java.util.ArrayList <java.util.Map <string, object> > list = this._enclosing.mUnfilteredData; results.values = list; results.count = list.size(); } else { string prefixString = prefix.ToString().ToLower(); java.util.ArrayList <java.util.Map <string, object> > unfilteredValues = this._enclosing .mUnfilteredData; int count = unfilteredValues.size(); java.util.ArrayList <java.util.Map <string, object> > newValues = new java.util.ArrayList <java.util.Map <string, object> >(count); { for (int i = 0; i < count; i++) { java.util.Map <string, object> h = unfilteredValues.get(i); if (h != null) { int len = this._enclosing.mTo.Length; { for (int j = 0; j < len; j++) { string str = (string)h.get(this._enclosing.mFrom[j]); string[] words = XobotOS.Runtime.Util.SplitStringRegex(str, " "); int wordCount = words.Length; { for (int k = 0; k < wordCount; k++) { string word = words[k]; if (word.ToLower().StartsWith(prefixString)) { newValues.add(h); break; } } } } } } } } results.values = newValues; results.count = newValues.size(); } return(results); }
/** * Constructor that wraps (not copies). * * @param map the map to decorate, must not be null * @param factory the factory to use, must not be null * @throws IllegalArgumentException if map or factory is null */ protected LazyMap(java.util.Map <Object, Object> map, Transformer factory) : base(map) { if (factory == null) { throw new java.lang.IllegalArgumentException("Factory must not be null"); } this.factory = factory; }
/** * Creates an {@code AttributedString} from the given text. * * @param value * the text to take as base for this attributed string. */ public AttributedString(System.String value) { if (value == null) { throw new java.lang.NullPointerException(); } text = value; attributeMap = new java.util.HashMap <AttributedCharacterIteratorNS.Attribute, java.util.List <IAC_Range> >();//11); }
/** * Creates an <code>XPathFilterParameterSpec</code> with the specified * XPath expression. * * @param xPath the XPath expression to be evaluated * @throws NullPointerException if <code>xPath</code> is <code>null</code> */ public XPathFilterParameterSpec(String xPath) { if (xPath == null) { throw new java.lang.NullPointerException(); } this.xPath = xPath; this.nsMap = new java.util.HashMap <String, String>();//Collections.EMPTY_MAP; }
/** * Constructs a new {@code ProcessBuilder} instance with the specified * operating system program and its arguments. Note that the list passed to * this constructor is not copied, so any subsequent updates to it are * reflected in this instance's state. * * @param command * the requested operating system program and its arguments. * @throws NullPointerException * if {@code command} is {@code null}. */ public ProcessBuilder(java.util.List<String> commandJ) : base() { if (commandJ == null) { throw new NullPointerException(); } this.commandJ = commandJ; java.lang.SystemJ.getProperties(); this.environmentJ = // new org.apache.harmony.luni.platform.Environment.EnvironmentMap( java.lang.SystemJ.getenv(); }
/** * Constructs a new instance of {@code Service} with the given * attributes. * * @param provider * the provider to which this service belongs. * @param type * the type of this service (for example {@code * KeyPairGenerator}). * @param algorithm * the algorithm this service implements. * @param className * the name of the class implementing this service. * @param aliases * {@code List} of aliases for the algorithm name, or {@code * null} if the implemented algorithm has no aliases. * @param attributes * {@code Map} of additional attributes, or {@code null} if * this {@code Service} has no attributed. * @throws NullPointerException * if {@code provider, type, algorithm} or {@code className} * is {@code null}. */ public Service(Provider provider, String type, String algorithm, String className, java.util.List<String> aliases, java.util.Map<String, String> attributes) { if (provider == null || type == null || algorithm == null || className == null) { throw new java.lang.NullPointerException(); } this.provider = provider; this.type = type; this.algorithm = algorithm; this.className = className; this.aliases = aliases; this.attributes = attributes; }
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); } } }
/** * Creates an {@code AttributedString} from the given text and the * attributes. The whole text has the given attributes applied. * * @param value * the text to take as base for this attributed string. * @param attributes * the attributes that the text is associated with. * @throws IllegalArgumentException * if the length of {@code value} is 0 but the size of {@code * attributes} is greater than 0. * @throws NullPointerException * if {@code value} is {@code null}. */ public AttributedString(System.String value, java.util.Map<AttributedCharacterIteratorNS.Attribute, System.Object> attributes) { if (value == null) { throw new java.lang.NullPointerException(); } if (value.Length == 0 && !attributes.isEmpty()) { // text.0B=Cannot add attributes to empty string throw new java.lang.IllegalArgumentException("Cannot add attributes to empty string"); //$NON-NLS-1$ } text = value; attributeMap = new java.util.HashMap<AttributedCharacterIteratorNS.Attribute, java.util.List<IAC_Range>>();//(attributes.size() * 4 / 3) + 1); java.util.Iterator<java.util.MapNS.Entry<AttributedCharacterIteratorNS.Attribute,System.Object>> it = attributes.entrySet().iterator(); while (it.hasNext()) { java.util.MapNS.Entry<AttributedCharacterIteratorNS.Attribute, System.Object> entry = it.next(); java.util.ArrayList<IAC_Range> ranges = new java.util.ArrayList<IAC_Range>(1); ranges.add(new IAC_Range(0, text.Length, entry.getValue())); attributeMap.put((AttributedCharacterIteratorNS.Attribute) entry .getKey(), ranges); } }
public EditorImpl(SharedPreferencesImpl _enclosing) { this._enclosing = _enclosing; mModified = null; mClear = false; }
/** * Creates an SQLClientInfoException object. The Reason string is set to * reason, and the Map<String,ClientInfoStatus> object is set to the failed * properties. * * @param reason * the string to use as the Reason string * @param failedProperties * the Map<String,ClientInfoStatus> object to use as the * property values */ public SQLClientInfoException(String reason, java.util.Map<String, ClientInfoStatus> failedProperties) : base(reason) { this.failedProperties = failedProperties; }
/** * Creates an SQLClientInfoException object. The Reason string is set to the * null if cause == null or cause.toString() if cause!=null, the cause * Throwable object is set to the given cause Throwable object, and the Map<String,ClientInfoStatus> * object is set to the failed properties. * * @param failedProperties * the Map<String,ClientInfoStatus> object to use as the * property values * @param cause * the Throwable object for the underlying reason this * SQLException */ public SQLClientInfoException( java.util.Map<String, ClientInfoStatus> failedProperties, java.lang.Throwable cause) : base(cause) { this.failedProperties = failedProperties; }
/** * Creates an SQLClientInfoException object. The Reason string is set to * reason, the SQLState string is set to the sqlState, the Error Code is set * to the vendorCode, and the Map<String,ClientInfoStatus> object is set to * the failed properties. * * @param reason * the string to use as the Reason string * @param sqlState * the string to use as the SQLState string * @param failedProperties * the Map<String,ClientInfoStatus> object to use as the * property values * @param cause * the Throwable object for the underlying reason this * SQLException */ public SQLClientInfoException(String reason, String sqlState, java.util.Map<String, ClientInfoStatus> failedProperties, java.lang.Throwable cause) : base(reason, sqlState, cause) { this.failedProperties = failedProperties; }
/** * Creates an SQLClientInfoException object. The Reason string is set to * reason, the SQLState string is set to the sqlState, the Error Code is set * to the vendorCode and the Map<String,ClientInfoStatus> object is set to * the failed properties. * * @param reason * the string to use as the Reason string * @param sqlState * the string to use as the SQLState string * @param vendorCode * the integer value for the error code * @param failedProperties * the Map<String,ClientInfoStatus> object to use as the * property values * */ public SQLClientInfoException(String reason, String sqlState, int vendorCode, java.util.Map<String, ClientInfoStatus> failedProperties) : base(reason, sqlState, vendorCode) { this.failedProperties = failedProperties; }
/** * Creates an <code>XPathType</code> instance with the specified XPath * expression and filter. * * @param expression the XPath expression to be evaluated * @param filter the filter operation ({@link Filter#INTERSECT}, * {@link Filter#SUBTRACT}, or {@link Filter#UNION}) * @throws NullPointerException if <code>expression</code> or * <code>filter</code> is <code>null</code> */ public XPathType(String expression, Filter filter) { if (expression == null) { throw new java.lang.NullPointerException("expression cannot be null"); } if (filter == null) { throw new java.lang.NullPointerException("filter cannot be null"); } this.expression = expression; this.filter = filter; this.nsMap = new java.util.HashMap<String,String>(); //this.nsMap = java.util.Collections<Object>.EMPTY_MAP; }
/** * Constructor that performs no validation. * Use <code>getInstance</code> if you want that. * * @param map the map to use for lookup, not cloned */ private MapTransformer(java.util.Map<Object, Object> map) : base() { iMap = map; }
/** * Creates an <code>XPathType</code> instance with the specified XPath * expression, filter, and namespace map. The map is copied to protect * against subsequent modification. * * @param expression the XPath expression to be evaluated * @param filter the filter operation ({@link Filter#INTERSECT}, * {@link Filter#SUBTRACT}, or {@link Filter#UNION}) * @param namespaceMap the map of namespace prefixes. Each key is a * namespace prefix <code>String</code> that maps to a corresponding * namespace URI <code>String</code>. * @throws NullPointerException if <code>expression</code>, * <code>filter</code> or <code>namespaceMap</code> are * <code>null</code> * @throws ClassCastException if any of the map's keys or entries are * not of type <code>String</code> */ public XPathType(String expression, Filter filter, java.util.Map<String,String> namespaceMap) : this(expression, filter) { if (namespaceMap == null) { throw new java.lang.NullPointerException("namespaceMap cannot be null"); } nsMap = unmodifiableCopyOfMap(namespaceMap); // generic using Map<String,String> also remove String checking }
/** * Creates an {@code AttributedString} from the given text. * * @param value * the text to take as base for this attributed string. */ public AttributedString(System.String value) { if (value == null) { throw new java.lang.NullPointerException(); } text = value; attributeMap = new java.util.HashMap<AttributedCharacterIteratorNS.Attribute, java.util.List<IAC_Range>>();//11); }
/** * 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(); }