public HashPMap<K,V> plusAll(final Map<? extends K, ? extends V> map) { HashPMap<K,V> result = this; for(Entry<? extends K,? extends V> entry : map.entrySet()) result = result.plus(entry.getKey(), entry.getValue()); return result; }
public HashPMap<K,V> plusAll(final Map<? extends K, ? extends V> map) { HashPMap<K,V> result = this; for(Entry<? extends K,? extends V> entry : map.entrySet()) result = result.plus(entry.getKey(), entry.getValue()); return result; }
/** * @param <K> * @param <V> * @param key * @param value * @return empty().plus(key, value) */ public static <K,V> HashPMap<K,V> singleton(final K key, final V value) { return HashTreePMap.<K,V>empty().plus(key, value); }
/** * @param <K> * @param <V> * @param key * @param value * @return empty().plus(key, value) */ public static <K,V> HashPMap<K,V> singleton(final K key, final V value) { return HashTreePMap.<K,V>empty().plus(key, value); }
public void testSerializationForHashPMapWithEntrySet() { /* regression test because entry set cache is unserializable, but wasn't marked as transient */ final HashPMap<String, Long> initialHashPMap = HashTreePMap.<String, Long> empty() .plus("key001", 23L) .plus("key002", 29L) .plus("key003", 31L); initialHashPMap.entrySet(); serializeToByteArray(initialHashPMap); // used to throw an exception }
public void testSingleton() { UtilityTest.assertEqualsAndHash(HashTreePMap.empty().plus(10, "test"), HashTreePMap.singleton(10, "test")); }
public void testSerializationForHashPMap() { final HashPMap<String, Long> initialHashPMap = HashTreePMap.<String, Long> empty() .plus("key001", 23L) .plus("key002", 29L) .plus("key003", 31L); final byte[] serializedThirdPHashPMap = serializeToByteArray(initialHashPMap); assertNotNull(serializedThirdPHashPMap); assertTrue(serializedThirdPHashPMap.length > 0); @SuppressWarnings("unchecked") final HashPMap<String, Long> deserializedHashPMap = (HashPMap<String, Long>) deserializeFromByteArray(serializedThirdPHashPMap, HashPMap.class); assertNotNull(deserializedHashPMap); assertEquals(Long.valueOf(23L), deserializedHashPMap.get("key001")); assertEquals(Long.valueOf(29L), deserializedHashPMap.get("key002")); assertEquals(Long.valueOf(31L), deserializedHashPMap.get("key003")); assertNotSame(initialHashPMap, deserializedHashPMap); assertEquals(initialHashPMap, deserializedHashPMap); }
public HashPMap<K,V> plusAll(final Map<? extends K, ? extends V> map) { HashPMap<K,V> result = this; for(Entry<? extends K,? extends V> entry : map.entrySet()) result = result.plus(entry.getKey(), entry.getValue()); return result; }
public HashPMap<K, V> plusAll(final Map<? extends K, ? extends V> map) { HashPMap<K, V> result = this; for (Entry<? extends K, ? extends V> entry : map.entrySet()) result = result.plus(entry.getKey(), entry.getValue()); return result; }
/** * @param <K> * @param <V> * @param key * @param value * @return empty().plus(key, value) */ public static <K,V> HashPMap<K,V> singleton(final K key, final V value) { return HashTreePMap.<K,V>empty().plus(key, value); }
/** * @param <K> * @param <V> * @param key * @param value * @return empty().plus(key, value) */ public static <K, V> HashPMap<K, V> singleton(final K key, final V value) { return HashTreePMap.<K, V>empty().plus(key, value); }
/** * @param map Collection. * @param evt Event. * @return Cloned map. */ protected static <E> Map<E, Integer> addToMap(@Nullable Map<E, Integer> map, E evt) { HashPMap<E, Integer> res = map == null ? HashTreePMap.<E, Integer>empty() : (HashPMap<E, Integer>)map; Integer cnt = res.get(evt); return cnt != null ? res.minus(evt).plus(evt, cnt + 1) : res.plus(evt, 1); }
/** * @param map Collection. * @param evt Event. * @return Cloned map. */ @Nullable protected static <E> Map<E, Integer> removeFromMap(@Nullable Map<E, Integer> map, E evt) { if (map == null) return null; HashPMap<E, Integer> res = (HashPMap<E, Integer>)map; Integer cnt = res.get(evt); return cnt == null ? res : cnt == 1 ? res.minus(evt) : res.minus(evt).plus(evt, cnt - 1); }
@SuppressWarnings("unchecked") public static <K extends Term, V extends Term> ImmutableMapSubstitution<K, V> composeAndEvaluate( Substitution<? extends K, ? extends V> substitution1, ImmutableMapSubstitution<? extends K, ? extends V> substitution2, TermContext context) { // on substitution composition: http://www.mathcs.duq.edu/simon/Fall04/notes-7-4/node4.html assert Sets.intersection(substitution1.keySet(), substitution2.keySet()).isEmpty() : "There shall be no common variables in the two substitution maps to be composed."; assert substitution2.keySet().stream().allMatch(key -> key instanceof Variable) : "Substitution composition is only supported for Variable -> Term substitutions"; HashPMap<K, V> entries = (HashPMap<K, V>) substitution2.entries; for (Entry<K, V> entry : ((Map<K, V>) substitution1).entrySet()) { entries = entries.plus( entry.getKey(), (V) entry.getValue().substituteAndEvaluate((Map<Variable, Term>) substitution2, context)); } return new ImmutableMapSubstitution<>(entries); }
@Override @SuppressWarnings("unchecked") public ImmutableMapSubstitution<K, V> evaluate(TermContext context) { HashPMap<K, V> evaluatedEntries = HashTreePMap.empty(); for (Entry<K, V> entry : entries.entrySet()) { evaluatedEntries = evaluatedEntries.plus( entry.getKey(), (V) entry.getValue().evaluate(context)); } return new ImmutableMapSubstitution<>(evaluatedEntries); }
@Override public ImmutableMapSubstitution<K, V> plus(K key, V value) { if (entries.get(key) != null) { if (entries.get(key).equals(value)) { return this; } else { return null; } } return new ImmutableMapSubstitution<>(entries.plus(key, value)); }