/** * Override superclass to ensure that MultiMap instances are * correctly handled. * <p> * NOTE: Prior to version 3.2, putAll(map) did not work properly * when passed a MultiMap. * * @param map the map to copy (either a normal or multi map) */ public void putAll(Map map) { if (map instanceof MultiMap) { for (Iterator it = map.entrySet().iterator(); it.hasNext();) { Map.Entry entry = (Map.Entry) it.next(); Collection coll = (Collection) entry.getValue(); putAll(entry.getKey(), coll); } } else { for (Iterator it = map.entrySet().iterator(); it.hasNext();) { Map.Entry entry = (Map.Entry) it.next(); put(entry.getKey(), entry.getValue()); } } }
public Object unmarshal(HierarchicalStreamReader reader, UnmarshallingContext context) { MultiHashMap map = new MultiHashMap(); while (reader.hasMoreChildren()) { reader.moveDown(); Object o = 0; if ("dataStore".equals(reader.getNodeName())) { o = context.convertAnother(map, DataStoreInfoImpl.class); } else { o = context.convertAnother(map, CoverageStoreInfoImpl.class); } map.put(o.getClass(), o); reader.moveUp(); } return map; } }
private void loadMap(MultiHashMap map) { // Set up so that we load the keys "randomly" // (i.e. we don't want to load int row-order, so that all like keys // load together. We want to mix it up...) int numRows = sMapPairs.length; int maxCols = 0; for (int ii = 0; ii < sMapPairs.length; ii++) { if (sMapPairs[ii].length > maxCols) { maxCols = sMapPairs[ii].length; } } for (int ii = 0; ii < maxCols; ii++) { for (int jj = 0; jj < numRows; jj++) { if (ii < sMapPairs[jj].length) { map.put(sMapPairs[jj][ii].mKey, sMapPairs[jj][ii].mValue); //--------------------------------------------------------- } } } assertTrue(map.size() == sMapPairs.length); }
/** * Override superclass to ensure that MultiMap instances are * correctly handled. * <p> * NOTE: Prior to version 3.2, putAll(map) did not work properly * when passed a MultiMap. * * @param map the map to copy (either a normal or multi map) */ public void putAll(Map map) { if (map instanceof MultiMap) { for (Iterator it = map.entrySet().iterator(); it.hasNext();) { Map.Entry entry = (Map.Entry) it.next(); Collection coll = (Collection) entry.getValue(); putAll(entry.getKey(), coll); } } else { for (Iterator it = map.entrySet().iterator(); it.hasNext();) { Map.Entry entry = (Map.Entry) it.next(); put(entry.getKey(), entry.getValue()); } } }
public void testIterator_Key() { MultiHashMap map = new MultiHashMap(); assertEquals(false, map.iterator("A").hasNext()); map.put("A", "AA"); Iterator it = map.iterator("A"); assertEquals(true, it.hasNext()); it.next(); assertEquals(false, it.hasNext()); }
public void testPutAll_Map2() { Map original = new HashMap(); original.put("keyX", "object1"); original.put("keyY", "object2"); MultiHashMap test = new MultiHashMap(); test.put("keyA", "objectA"); test.put("keyX", "object0"); test.putAll(original); assertEquals(3, test.size()); assertEquals(4, test.totalSize()); assertEquals(1, test.getCollection("keyA").size()); assertEquals(2, test.getCollection("keyX").size()); assertEquals(1, test.getCollection("keyY").size()); assertEquals(true, test.containsValue("objectA")); assertEquals(true, test.containsValue("object0")); assertEquals(true, test.containsValue("object1")); assertEquals(true, test.containsValue("object2")); }
public void testMapEquals() { MultiHashMap one = new MultiHashMap(); Integer value = new Integer(1); one.put("One", value); one.remove("One", value); MultiHashMap two = new MultiHashMap(); assertEquals(two, one); }
public void testPutAll_Map1() { MultiMap original = new MultiHashMap(); original.put("key", "object1"); original.put("key", "object2"); MultiHashMap test = new MultiHashMap(); test.put("keyA", "objectA"); test.put("key", "object0"); test.putAll(original); assertEquals(2, test.size()); assertEquals(4, test.totalSize()); assertEquals(1, test.getCollection("keyA").size()); assertEquals(3, test.getCollection("key").size()); assertEquals(true, test.containsValue("objectA")); assertEquals(true, test.containsValue("object0")); assertEquals(true, test.containsValue("object1")); assertEquals(true, test.containsValue("object2")); }
public void testGetCollection() { MultiHashMap map = new MultiHashMap(); map.put("A", "AA"); assertSame(map.get("A"), map.getCollection("A")); }
public void testRemove_KeyItem() { MultiHashMap map = new MultiHashMap(); map.put("A", "AA"); map.put("A", "AB"); map.put("A", "AC"); assertEquals(null, map.remove("C", "CA")); assertEquals(null, map.remove("A", "AD")); assertEquals("AC", map.remove("A", "AC")); assertEquals("AB", map.remove("A", "AB")); assertEquals("AA", map.remove("A", "AA")); assertEquals(new MultiHashMap(), map); }
public void testTotalSize() { MultiHashMap map = new MultiHashMap(); assertEquals(0, map.totalSize()); map.put("A", "AA"); assertEquals(1, map.totalSize()); map.put("B", "BA"); assertEquals(2, map.totalSize()); map.put("B", "BB"); assertEquals(3, map.totalSize()); map.put("B", "BC"); assertEquals(4, map.totalSize()); map.remove("A"); assertEquals(3, map.totalSize()); map.remove("B", "BC"); assertEquals(2, map.totalSize()); }
public void testClone() { MultiHashMap map = new MultiHashMap(); map.put("A", "1"); map.put("A", "2"); Collection coll = (Collection) map.get("A"); assertEquals(1, map.size()); assertEquals(2, coll.size()); MultiHashMap cloned = (MultiHashMap) map.clone(); Collection clonedColl = (Collection) cloned.get("A"); assertNotSame(map, cloned); assertNotSame(coll, clonedColl); assertEquals(1, map.size()); assertEquals(2, coll.size()); assertEquals(1, cloned.size()); assertEquals(2, clonedColl.size()); map.put("A", "3"); assertEquals(1, map.size()); assertEquals(3, coll.size()); assertEquals(1, cloned.size()); assertEquals(2, clonedColl.size()); }
public void testConstructorCopy1() { MultiHashMap map = new MultiHashMap(); map.put("A", "1"); map.put("A", "2"); Collection coll = (Collection) map.get("A"); assertEquals(1, map.size()); assertEquals(2, coll.size()); MultiHashMap newMap = new MultiHashMap(map); Collection newColl = (Collection) newMap.get("A"); assertNotSame(map, newMap); assertNotSame(coll, newColl); assertEquals(1, map.size()); assertEquals(2, coll.size()); assertEquals(1, newMap.size()); assertEquals(2, newColl.size()); map.put("A", "3"); assertEquals(1, map.size()); assertEquals(3, coll.size()); assertEquals(1, newMap.size()); assertEquals(2, newColl.size()); }
public void testContainsValue_Key() { MultiHashMap map = new MultiHashMap(); assertEquals(false, map.containsValue("A", "AA")); assertEquals(false, map.containsValue("B", "BB")); map.put("A", "AA"); assertEquals(true, map.containsValue("A", "AA")); assertEquals(false, map.containsValue("A", "AB")); }
public void testSize_Key() { MultiHashMap map = new MultiHashMap(); assertEquals(0, map.size("A")); assertEquals(0, map.size("B")); map.put("A", "AA"); assertEquals(1, map.size("A")); assertEquals(0, map.size("B")); map.put("B", "BA"); assertEquals(1, map.size("A")); assertEquals(1, map.size("B")); map.put("B", "BB"); assertEquals(1, map.size("A")); assertEquals(2, map.size("B")); map.put("B", "BC"); assertEquals(1, map.size("A")); assertEquals(3, map.size("B")); map.remove("A"); assertEquals(0, map.size("A")); assertEquals(3, map.size("B")); map.remove("B", "BC"); assertEquals(0, map.size("A")); assertEquals(2, map.size("B")); }
map.put(property[0], property[1]);
/** * Registers a synonym between to media types. * <p> * A synonym is considered to be an equivlance for functional purposes. An example would be * registering a synonym for {@link MediaType#APPLICATION_XML} as {@link MediaType#TEXT_XML}. * </p> * @param mediaType The type. * @param synonym A synonym for the type. */ public static void registerSynonym( MediaType mediaType, MediaType synonym ) { instance.synonyms.put( mediaType, synonym ); }
public Object put( Object arg0, Object arg1 ) { return map.put( arg0, arg1 ); }
public void addListener(final FilesystemAlterationListener listener, final File directory) { synchronized (mutexListeners) { // listerner -> dir1, dir2, dir3 final MultiHashMap newListeners = new MultiHashMap(listeners); newListeners.put(listener, directory); listeners = newListeners; // directory -> listener1, listener2, listener3 final MultiHashMap newDirectories = new MultiHashMap(directories); newDirectories.put(directory, listener); directories = newDirectories; } }