@Override public int compareTo(FieldValue fieldValue) { int comp = super.compareTo(fieldValue); if (comp != 0) { return comp; } //types are equal, this must be of this type MapFieldValue<K,V> rhs = (MapFieldValue<K,V>) fieldValue; if (size() < rhs.size()) { return -1; } else if (size() > rhs.size()) { return 1; } Map.Entry<K,V> [] entries = entrySet().toArray(new Map.Entry[size()]); Map.Entry<K,V> [] rhsEntries = rhs.entrySet().toArray(new Map.Entry[rhs.size()]); Arrays.sort(entries, Comparator.comparing(Map.Entry<K,V>::getKey)); Arrays.sort(rhsEntries, Comparator.comparing(Map.Entry<K,V>::getKey)); for (int i = 0; i < entries.length; i++) { comp = entries[i].getKey().compareTo(rhsEntries[i].getKey()); if (comp != 0) return comp; comp = entries[i].getValue().compareTo(rhsEntries[i].getValue()); if (comp != 0) return comp; } return 0; }
/** * Add a key with an associated weight to this set. If the key is already present in this set, the previous * association is replaced. * * @param key the key to add * @param weight the weight to associate with this key * @return the weight that was previously associated with this key, or null (if there was no previous key) */ public IntegerFieldValue putUnChecked(K key, IntegerFieldValue weight) { return map.put(key, weight); }
@Override public MapFieldValue createFieldValue() { return new MapFieldValue(this); }
@Override public void assign(Object o) { if (!checkAssign(o)) { return; } if (o instanceof MapFieldValue) { if (o == this) return; MapFieldValue a = (MapFieldValue) o; values.clear(); putAll(a); } else if (o instanceof Map) { values = new MapWrapper((Map)o); } else { throw new IllegalArgumentException("Class " + o.getClass() + " not applicable to an " + this.getClass() + " instance."); } }
public <K extends FieldValue, V extends FieldValue> void read(FieldBase field, MapFieldValue<K, V> map) { try { MapDataType dt = map.getDataType(); while (reader.hasNext()) { int type = reader.next(); if (type == XMLStreamReader.START_ELEMENT) { if ("item".equals(reader.getName().toString())) { KeyAndValue kv = new KeyAndValue(); readKeyAndValue(field, kv, dt); if (kv.key == null || kv.value == null) { throw newDeserializeException(field, "Map items must specify both key and value"); } // noinspection unchecked map.put((K)kv.key, (V)kv.value); skipToEnd("item"); } else { throw newDeserializeException(field, "Illegal tag " + reader.getName() + " expected 'item'"); } } else if (type == XMLStreamReader.END_ELEMENT) { return; } } } catch (XMLStreamException e) { throw newException(field, e); } }
/** * Checks if another object is equal to this set. * * @param o the object to check for equality with * @return true if o is an instance of WeightedSet and the two encapsulated Maps are equal, false otherwise */ public boolean equals(Object o) { if (!(o instanceof MapFieldValue)) return false; return super.equals(o) && entrySet().equals(((MapFieldValue) o).entrySet()); }
Map<FieldValue, FieldValue> next = new LinkedHashMap<FieldValue, FieldValue>(); DataType nextKeyType = null, nextValType = null; for (Map.Entry<FieldValue, FieldValue> entry : val.entrySet()) { FieldValue prevKey = entry.getKey(); FieldValue nextKey = convert(prevKey); ret.put(entry.getKey(), entry.getValue());
wasModified = checkAndRemove(fieldPath.get(pos).getLookupKey(), val.iterateNested(fieldPath, pos + 1, handler), wasModified, keysToRemove); } else if (handler.createMissingPath()) { val = getDataType().getValueType().createFieldValue(); FieldPathIteratorHandler.ModificationStatus status = val.iterateNested(fieldPath, pos + 1, handler); if (status == FieldPathIteratorHandler.ModificationStatus.MODIFIED) { put((K)fieldPath.get(pos).getLookupKey(), (V)val); return status; wasModified = checkAndRemove(f, f.iterateNested(fieldPath, pos + 1, handler), wasModified, keysToRemove); wasModified = checkAndRemove(entry.getKey(), entry.getValue().iterateNested(fieldPath, pos + 1, handler), wasModified, keysToRemove); FieldValue val = values.get(idx.getKey()); if (val != null) { wasModified = checkAndRemove(idx.getKey(), val.iterateNested(fieldPath, pos + 1, handler), wasModified, keysToRemove); wasModified = checkAndRemove(entry.getKey(), entry.getValue().iterateNested(fieldPath, pos + 1, handler), wasModified, keysToRemove); wasModified = checkAndRemove(entry.getKey(), entry.getKey().iterateNested(fieldPath, pos, handler), wasModified, keysToRemove); wasModified = checkAndRemove(entry.getKey(), entry.getKey().iterateNested(fieldPath, pos, handler), wasModified, keysToRemove);
public <K extends FieldValue, V extends FieldValue> void read(FieldBase field, MapFieldValue<K, V> map) { int numElements = getNumCollectionElems(); Map<K,V> hash = new HashMap<>(); MapDataType type = map.getDataType(); for (int i = 0; i < numElements; i++) { if (version < 7) { getInt(null); // We don't need size for anything } K key = (K) type.getKeyType().createFieldValue(); V val = (V) type.getValueType().createFieldValue(); key.deserialize(null, this); val.deserialize(null, this); hash.put(key, val); } map.clear(); map.putAll(hash); }
@Override public void assign(Object o) { if (!checkAssign(o)) { return; } if (o instanceof WeightedSet) { WeightedSet wset = (WeightedSet) o; if (getDataType().equals(wset.getDataType())) { map.assign(wset.map); } else { throw new IllegalArgumentException("Cannot assign a weighted set of type " + wset.getDataType() + " to a weighted set of type " + getDataType()); } } else if (o instanceof Map) { map = new WeightedSetWrapper((Map)o, map.getDataType()); } else { throw new IllegalArgumentException("Class " + o.getClass() + " not applicable to an " + this.getClass() + " instance."); } }
/** * Checks whether this set contains the specified key. * * @param key the key to search for * @return true if this set contains this key */ public boolean containsKey(Object key) { return map.containsKey(key); }
/** Remove all key-weight associations in this set. */ public void clear() { map.clear(); }
@Override public WeightedSet clone() { WeightedSet<K> newSet = (WeightedSet<K>) super.clone(); newSet.map = (MapFieldValue<K, IntegerFieldValue>) map.clone(); return newSet; }
@Override public int compareTo(FieldValue fieldValue) { int comp = super.compareTo(fieldValue); if (comp != 0) { return comp; } return map.compareTo(((WeightedSet<K>)fieldValue).map); }
@SuppressWarnings({ "rawtypes", "cast", "unchecked" }) public static void fillMapFromObject(TokenBuffer buffer, MapFieldValue parent) { JsonToken token = buffer.currentToken(); int initNesting = buffer.nesting(); expectObjectStart(token); token = buffer.next(); DataType keyType = parent.getDataType().getKeyType(); DataType valueType = parent.getDataType().getValueType(); while (buffer.nesting() >= initNesting) { FieldValue key = readAtomic(buffer.currentName(), keyType); FieldValue value = readSingleValue(buffer, valueType); Preconditions.checkState(key != null && value != null, "Missing key or value for map entry."); parent.put(key, value); token = buffer.next(); } expectObjectEnd(token); }
Map<K, Integer> getPrimitiveMap() { Map<K, Integer> retVal = new LinkedHashMap<>(); for (Entry<K, IntegerFieldValue> entry : map.entrySet()) { retVal.put(entry.getKey(), entry.getValue().getInteger()); } return retVal; }
public <K extends FieldValue, V extends FieldValue> void read(FieldBase field, MapFieldValue<K, V> map) { int numElements = getNumCollectionElems(); Map<K,V> hash = new HashMap<>(); MapDataType type = map.getDataType(); for (int i = 0; i < numElements; i++) { if (version < 7) { getInt(null); // We don't need size for anything } K key = (K) type.getKeyType().createFieldValue(); V val = (V) type.getValueType().createFieldValue(); key.deserialize(null, this); val.deserialize(null, this); hash.put(key, val); } map.clear(); map.putAll(hash); }
@SuppressWarnings({ "rawtypes", "cast", "unchecked" }) public static void fillMapFromArray(TokenBuffer buffer, MapFieldValue parent) { JsonToken token = buffer.currentToken(); int initNesting = buffer.nesting(); expectArrayStart(token); token = buffer.next(); DataType keyType = parent.getDataType().getKeyType(); DataType valueType = parent.getDataType().getValueType(); while (buffer.nesting() >= initNesting) { FieldValue key = null; FieldValue value = null; expectObjectStart(token); token = buffer.next(); for (int i = 0; i < 2; ++i) { if (MAP_KEY.equals(buffer.currentName())) { key = readSingleValue(buffer, keyType); } else if (MAP_VALUE.equals(buffer.currentName())) { value = readSingleValue(buffer, valueType); } token = buffer.next(); } Preconditions.checkState(key != null && value != null, "Missing key or value for map entry."); parent.put(key, value); expectObjectEnd(token); token = buffer.next(); // array end or next entry } }
/** * Uses toString() from the encapsulated Map. * * @return the toString() of this set */ public String toString() { StringBuilder sb = new StringBuilder(); sb.append("WeightedSet(").append(getDataType()); for (Map.Entry entry : map.entrySet()) { sb.append("\n key: ").append(entry.getKey().getClass()).append(": ").append(entry.getKey()); sb.append("\n value: ").append(entry.getValue().getClass()).append(": ").append(entry.getValue()); } return sb.append("\n)").toString(); }