/** * 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)); }
/** * 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)); }
/** * Constructor copying elements from another map. * * @param map the map to copy, must be size 1 * @throws NullPointerException if the map is null * @throws IllegalArgumentException if the size is not 1 */ public SingletonMap(java.util.Map <Object, Object> map) { if (map.size() != 1) { throw new java.lang.IllegalArgumentException("The map size must be 1"); } java.util.MapNS.Entry <Object, Object> entry = (java.util.MapNS.Entry <Object, Object>)map.entrySet().iterator().next(); this.key = entry.getKey(); this.value = entry.getValue(); }
//----------------------------------------------------------------------- /** * Write the map out using a custom routine. * @param out the output stream * @throws IOException */ protected virtual void doWriteObject(java.io.ObjectOutputStream outJ) {//throws IOException { outJ.writeInt(map.size()); for (java.util.Iterator <java.util.MapNS.Entry <Object, Object> > it = map.entrySet().iterator(); it.hasNext();) { java.util.MapNS.Entry <Object, Object> entry = (java.util.MapNS.Entry <Object, Object>)it.next(); outJ.writeObject(entry.getKey()); outJ.writeInt(((MutableInteger)entry.getValue()).value); } }
/** * Factory method to create a transforming map that will transform * existing contents of the specified map. * <p> * If there are any elements already in the map being decorated, they * will be transformed by this method. * Constrast this with {@link #decorate}. * * @param map the map to decorate, must not be null * @param keyTransformer the transformer to use for key conversion, null means no transformation * @param valueTransformer the transformer to use for value conversion, null means no transformation * @throws IllegalArgumentException if map is null * @since Commons Collections 3.2 */ public static java.util.Map <Object, Object> decorateTransform(java.util.Map <Object, Object> map, Transformer keyTransformer, Transformer valueTransformer) { TransformedMap decorated = new TransformedMap(map, keyTransformer, valueTransformer); if (map.size() > 0) { java.util.Map <Object, Object> transformed = decorated.transformMap(map); decorated.clear(); decorated.getMap().putAll(transformed); // avoids double transformation } return(decorated); }
/** * Transforms a map. * <p> * The transformer itself may throw an exception if necessary. * * @param map the map to transform * @throws the transformed object */ protected virtual java.util.Map <Object, Object> transformMap(java.util.Map <Object, Object> map) { if (map.isEmpty()) { return(map); } java.util.Map <Object, Object> result = new LinkedMap(map.size()); 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(); result.put(transformKey(entry.getKey()), transformValue(entry.getValue())); } return(result); }
/** * Puts the values from the specified map into this map. * <p> * The map must be of size 0 or size 1. * If it is size 1, the key must match the key of this map otherwise an * IllegalArgumentException is thrown. * * @param map the map to add, must be size 0 or 1, and the key must match * @throws NullPointerException if the map is null * @throws IllegalArgumentException if the key does not match */ public virtual void putAll(java.util.Map <Object, Object> map) { switch (map.size()) { case 0: return; case 1: java.util.MapNS.Entry <Object, Object> entry = (java.util.MapNS.Entry <Object, Object>)map.entrySet().iterator().next(); put(entry.getKey(), entry.getValue()); return; default: throw new java.lang.IllegalArgumentException("The map size must be 0 or 1"); } }
/** * Compares this map with another. * * @param obj the object to compare to * @return true if equal */ public override bool Equals(Object obj) { if (obj == this) { return(true); } if (obj is java.util.Map <Object, Object> == false) { return(false); } java.util.Map <Object, Object> other = (java.util.Map <Object, Object>)obj; if (other.size() != 1) { return(false); } java.util.MapNS.Entry <Object, Object> entry = (java.util.MapNS.Entry <Object, Object>)other.entrySet().iterator().next(); return(isEqualKey(entry.getKey()) && isEqualValue(entry.getValue())); }
/** * Create a new Transformer that uses the input object as a key to find the * transformer to call. * <p> * The Map consists of object keys and Transformer values. A transformer * is called if the input object equals the key. If there is no match, the * default transformer is called. The default transformer is set in the map * using a null key. If no default is set, null will be returned in a default case. * * @see org.apache.commons.collections.functors.SwitchTransformer * * @param objectsAndTransformers a map of objects to transformers * @return the transformer * @throws IllegalArgumentException if the map is null * @throws IllegalArgumentException if the map is empty * @throws IllegalArgumentException if any transformer in the map is null */ public static Transformer switchMapTransformer(java.util.Map <Object, Object> objectsAndTransformers) { Transformer[] trs = null; Predicate[] preds = null; if (objectsAndTransformers == null) { throw new java.lang.IllegalArgumentException("The object and transformer map must not be null"); } Transformer def = (Transformer)objectsAndTransformers.remove(null); int size = objectsAndTransformers.size(); trs = new Transformer[size]; preds = new Predicate[size]; int i = 0; for (java.util.Iterator <java.util.MapNS.Entry <Object, Object> > it = objectsAndTransformers.entrySet().iterator(); it.hasNext();) { java.util.MapNS.Entry <Object, Object> entry = (java.util.MapNS.Entry <Object, Object>)it.next(); preds[i] = EqualPredicate.getInstance(entry.getKey()); trs[i] = (Transformer)entry.getValue(); i++; } return(switchTransformer(preds, trs, def)); }
/** * Starts a new process based on the current state of this process builder. * * @return the new {@code Process} instance. * @throws NullPointerException * if any of the elements of {@link #command()} is {@code null}. * @throws IndexOutOfBoundsException * if {@link #command()} is empty. * @throws SecurityException * if {@link SecurityManager#checkExec(String)} doesn't allow * process creation. * @throws IOException * if an I/O error happens. */ public Process start()//throws IOException { { if (commandJ.isEmpty()) { throw new IndexOutOfBoundsException(); } String[] cmdArray = new String[commandJ.size()]; for (int i = 0; i < cmdArray.Length; i++) { if ((cmdArray[i] = commandJ.get(i)) == null) { throw new NullPointerException(); } } String[] envArray = new String[environmentJ.size()]; int i2 = 0; /* * foreach (Map.Entry<String, String> entry in environmentJ.entrySet()) { * envArray[i2++] = entry.getKey() + "=" + entry.getValue(); //$NON-NLS-1$ * } */ java.util.Iterator <String> it = environmentJ.keySet().iterator(); while (it.hasNext()) { String key = it.next(); String value = environmentJ.get(key); envArray[i2++] = key + "=" + value; } java.lang.Process process = Runtime.getRuntime().exec(cmdArray, envArray, directoryJ); // TODO implement support for redirectErrorStream return(process); }
/** * Create a new Closure that uses the input object as a key to find the * closure to call. * <p> * The Map consists of object keys and Closure values. A closure * is called if the input object equals the key. If there is no match, the * default closure is called. The default closure is set in the map * using a null key. * * @see org.apache.commons.collections.functors.SwitchClosure * * @param objectsAndClosures a map of objects to closures * @return the closure * @throws IllegalArgumentException if the map is null * @throws IllegalArgumentException if the map is empty * @throws IllegalArgumentException if any closure in the map is null */ public static Closure switchMapClosure(java.util.Map <Object, Object> objectsAndClosures) { Closure[] trs = null; Predicate[] preds = null; if (objectsAndClosures == null) { throw new java.lang.IllegalArgumentException("The object and closure map must not be null"); } Closure def = (Closure)objectsAndClosures.remove(null); int size = objectsAndClosures.size(); trs = new Closure[size]; preds = new Predicate[size]; int i = 0; for (java.util.Iterator <java.util.MapNS.Entry <Object, Object> > it = objectsAndClosures.entrySet().iterator(); it.hasNext();) { java.util.MapNS.Entry <Object, Object> entry = it.next(); preds[i] = EqualPredicate.getInstance(entry.getKey()); trs[i] = (Closure)entry.getValue(); i++; } return(switchClosure(preds, trs, def)); }
//----------------------------------------------------------------------- public int size() { return(map.size()); }
/** * Constructor that copies the input map creating an independent copy. * <p> * This method performs different behaviour depending on whether the map * specified is a MultiMap or not. If a MultiMap is specified, each internal * collection is also cloned. If the specified map only implements Map, then * the values are not cloned. * <p> * NOTE: From Commons Collections 3.1 this method correctly copies a MultiMap * to form a truly independent new map. * NOTE: From Commons Collections 3.2 this method delegates to the newly * added putAll(Map) override method. * * @param mapToCopy a Map to copy */ public MultiHashMap(java.util.Map <Object, Object> mapToCopy) : base((int)(mapToCopy.size() * 1.4f)) { putAll(mapToCopy); }
// Basic object methods // ---------------------------------------------------------------------- /** * Compare the specified object with this list for equality. This * implementation uses exactly the code that is used to define the * list equals function in the documentation for the * <code>Map.equals</code> method. * * @param o the object to be compared to this list * @return true if the two maps are equal */ public override bool Equals(Object o) { // Simple tests that require no synchronization if (o == this) { return(true); } else if (!(o is java.util.Map <Object, Object>)) { return(false); } java.util.Map <Object, Object> mo = (java.util.Map <Object, Object>)o; // Compare the two maps for equality if (fast) { if (mo.size() != map.size()) { return(false); } java.util.Iterator <java.util.MapNS.Entry <Object, Object> > i = map.entrySet().iterator(); while (i.hasNext()) { java.util.MapNS.Entry <Object, Object> e = i.next(); Object key = e.getKey(); Object value = e.getValue(); if (value == null) { if (!(mo.get(key) == null && mo.containsKey(key))) { return(false); } } else { if (!value.equals(mo.get(key))) { return(false); } } } return(true); } else { lock (map) { if (mo.size() != map.size()) { return(false); } java.util.Iterator <java.util.MapNS.Entry <Object, Object> > i = map.entrySet().iterator(); while (i.hasNext()) { java.util.MapNS.Entry <Object, Object> e = i.next(); Object key = e.getKey(); Object value = e.getValue(); if (value == null) { if (!(mo.get(key) == null && mo.containsKey(key))) { return(false); } } else { if (!value.equals(mo.get(key))) { return(false); } } } return(true); } } }
/** * Constructor copying elements from another map. * <p/> * The maximum size is set from the map's size. * * @param map the map to copy * @param scanUntilRemovable scan until a removeable entry is found, default false * @throws NullPointerException if the map is null * @throws IllegalArgumentException if the map is empty * @since Commons Collections 3.1 */ public LRUMap(java.util.Map <Object, Object> map, bool scanUntilRemovable) : this(map.size(), DEFAULT_LOAD_FACTOR, scanUntilRemovable) { putAll(map); }
static internal java.util.Map DeriveStyle(java.util.Map attribs, FontStyle style, bool createNew) { java.util.Map newAttribs; if (createNew) { newAttribs = new java.util.Hashtable(attribs.size()); java.util.Iterator it = attribs.keySet().iterator(); while (it.hasNext()) { object key = it.next(); object value = attribs.get(key); if (value != null) { newAttribs.put(key, value); } } } else { newAttribs = attribs; } //Bold if ((style & FontStyle.Bold) == FontStyle.Bold) { newAttribs.put(TextAttribute.WEIGHT, TextAttribute.WEIGHT_BOLD); } else { newAttribs.remove(TextAttribute.WEIGHT); } //Italic if ((style & FontStyle.Italic) == FontStyle.Italic) { newAttribs.put(TextAttribute.POSTURE, TextAttribute.POSTURE_OBLIQUE); } else { newAttribs.put(TextAttribute.POSTURE, TextAttribute.POSTURE_REGULAR); } //Underline if ((style & FontStyle.Underline) == FontStyle.Underline) { newAttribs.put(TextAttribute.UNDERLINE, TextAttribute.UNDERLINE_ON); } else { newAttribs.remove(TextAttribute.UNDERLINE); } //Strikeout if ((style & FontStyle.Strikeout) == FontStyle.Strikeout) { newAttribs.put(TextAttribute.STRIKETHROUGH, TextAttribute.STRIKETHROUGH_ON); } else { newAttribs.remove(TextAttribute.STRIKETHROUGH); } return(newAttribs); }
public virtual int size() { return(map.size()); }
private void setPermissions(java.util.List <android.content.pm.PermissionInfo> permList ) { mGroupLabelCache = new java.util.HashMap <string, java.lang.CharSequence>(); //add the default label so that uncategorized permissions can go here mGroupLabelCache.put(mDefaultGrpName, java.lang.CharSequenceProxy.Wrap(mDefaultGrpLabel )); // Map containing group names and a list of permissions under that group // categorized as dangerous mDangerousMap = new java.util.HashMap <string, string>(); // Map containing group names and a list of permissions under that group // categorized as normal mNormalMap = new java.util.HashMap <string, string>(); // Additional structures needed to ensure that permissions are unique under // each group java.util.Map <string, java.util.List <android.content.pm.PermissionInfo> > dangerousMap = new java.util.HashMap <string, java.util.List <android.content.pm.PermissionInfo > >(); java.util.Map <string, java.util.List <android.content.pm.PermissionInfo> > normalMap = new java.util.HashMap <string, java.util.List <android.content.pm.PermissionInfo > >(); android.widget.AppSecurityPermissions.PermissionInfoComparator permComparator = new android.widget.AppSecurityPermissions.PermissionInfoComparator(mPm); if (permList != null) { // First pass to group permissions foreach (android.content.pm.PermissionInfo pInfo in Sharpen.IterableProxy.Create( permList)) { if (localLOGV) { android.util.Log.i(TAG, "Processing permission:" + pInfo.name); } if (!isDisplayablePermission(pInfo)) { if (localLOGV) { android.util.Log.i(TAG, "Permission:" + pInfo.name + " is not displayable"); } continue; } java.util.Map <string, java.util.List <android.content.pm.PermissionInfo> > permInfoMap = (pInfo.protectionLevel == android.content.pm.PermissionInfo.PROTECTION_DANGEROUS ) ? dangerousMap : normalMap; string grpName = (pInfo.group == null) ? mDefaultGrpName : pInfo.group; if (localLOGV) { android.util.Log.i(TAG, "Permission:" + pInfo.name + " belongs to group:" + grpName ); } java.util.List <android.content.pm.PermissionInfo> grpPermsList = permInfoMap.get( grpName); if (grpPermsList == null) { grpPermsList = new java.util.ArrayList <android.content.pm.PermissionInfo>(); permInfoMap.put(grpName, grpPermsList); grpPermsList.add(pInfo); } else { int idx = java.util.Collections.binarySearch(grpPermsList, pInfo, permComparator); if (localLOGV) { android.util.Log.i(TAG, "idx=" + idx + ", list.size=" + grpPermsList.size()); } if (idx < 0) { idx = -idx - 1; grpPermsList.add(idx, pInfo); } } } // Second pass to actually form the descriptions // Look at dangerous permissions first aggregateGroupDescs(dangerousMap, mDangerousMap); aggregateGroupDescs(normalMap, mNormalMap); } mCurrentState = android.widget.AppSecurityPermissions.State.NO_PERMS; if (mDangerousMap.size() > 0) { mCurrentState = (mNormalMap.size() > 0) ? android.widget.AppSecurityPermissions.State .BOTH : android.widget.AppSecurityPermissions.State.DANGEROUS_ONLY; } else { if (mNormalMap.size() > 0) { mCurrentState = android.widget.AppSecurityPermissions.State.NORMAL_ONLY; } } if (localLOGV) { android.util.Log.i(TAG, "mCurrentState=" + mCurrentState); } showPermissions(); }