Package convex.core.data

Class AMap<K extends ACell,V extends ACell>

java.lang.Object
convex.core.data.AObject
convex.core.data.ACell
convex.core.data.ACountable<E>
convex.core.data.ADataStructure<MapEntry<K,V>>
convex.core.data.AMap<K,V>
Type Parameters:
K - Type of keys
V - Type of values
All Implemented Interfaces:
IAssociative<K,V>, IValidated, IWriteable, Map<K,V>
Direct Known Subclasses:
ABlobMap, AHashMap, ARecord
public abstract class AMap<K extends ACell,V extends ACell> extends ADataStructure<MapEntry<K,V>> implements Map<K,V>, IAssociative<K,V>
Abstract base class for maps. Maps are Smart Data Structures that represent an immutable mapping of keys to values. The can also be seen as a data structure where the elements are map entries (equivalent to length 2 vectors) Ordering of map entries (as seen through iterators etc.) depends on map type.

  • Constructor Details

    • AMap

      protected AMap(long count)

  • Method Details

    • getType

      public AType getType()
      Description copied from class: ACell
      Gets the most specific known runtime Type for this Cell.
      Overrides:
      getType in class ACell
      Returns:
      The Type of this Call

    • values

      public AVector<V> values()
      Gets the values from this map, in map-determined order
      Specified by:
      values in interface Map<K extends ACell,V extends ACell>

    • assoc

      public abstract AMap<K,V> assoc(ACell key, ACell value)
      Associates the given key with the specified value.
      Specified by:
      assoc in class ADataStructure<MapEntry<K extends ACell,V extends ACell>>
      Parameters:
      key - Map key to associate
      value - Map value
      Returns:
      An updated map with the new association, or null if the association fails

    • dissoc

      public abstract AMap<K,V> dissoc(ACell key)
      Dissociates a key from this map, returning an updated map if the key was removed, or the same unchanged map if the key is not present.
      Parameters:
      key - Key to remove.
      Returns:
      Updated map

    • containsKeyRef

      public final boolean containsKeyRef(Ref<ACell> ref)

    • containsKey

      public boolean containsKey(ACell key)
      Description copied from class: ADataStructure
      Checks if the data structure contains the specified key
      Specified by:
      containsKey in class ADataStructure<MapEntry<K extends ACell,V extends ACell>>
      Parameters:
      key - Associative key to look up
      Returns:
      true if the data structure contains the key, false otherwise

    • containsKey

      public final boolean containsKey(Object key)
      Specified by:
      containsKey in interface Map<K extends ACell,V extends ACell>

    • containsValue

      public final boolean containsValue(Object value)
      Specified by:
      containsValue in interface Map<K extends ACell,V extends ACell>

    • containsValue

      public abstract boolean containsValue(ACell value)
      CHecks if this map contains the given value. WARNING: probably O(n)
      Parameters:
      value - Value to check
      Returns:
      true if map contains value, false otherwise

    • getKeyRefEntry

      public abstract MapEntry<K,V> getKeyRefEntry(Ref<ACell> ref)
      Get an entry given a Ref to the key value. This is more efficient than directly looking up using the key for some map types, and should be preferred if the caller already has a Ref available.
      Parameters:
      ref - Ref to Map key
      Returns:
      MapEntry for the given key ref

    • accumulateEntrySet

      protected abstract void accumulateEntrySet(HashSet<Map.Entry<K,V>> h)
      Accumulate all entries from this map in the given HashSet.
      Parameters:
      h - HashSet in which to accumulate entries

    • accumulateKeySet

      protected abstract void accumulateKeySet(HashSet<K> h)
      Accumulate all keys from this map in the given HashSet.
      Parameters:
      h - HashSet in which to accumulate keys

    • accumulateValues

      protected abstract void accumulateValues(ArrayList<V> al)
      Accumulate all values from this map in the given ArrayList.
      Parameters:
      al - ArrayList in which to accumulate values

    • put

      public final V put(K key, V value)
      Specified by:
      put in interface Map<K extends ACell,V extends ACell>

    • remove

      public final V remove(Object key)
      Specified by:
      remove in interface Map<K extends ACell,V extends ACell>

    • putAll

      public final void putAll(Map<? extends K,? extends V> m)
      Specified by:
      putAll in interface Map<K extends ACell,V extends ACell>

    • clear

      public final void clear()
      Specified by:
      clear in interface Map<K extends ACell,V extends ACell>

    • forEach

      public abstract void forEach(BiConsumer<? super K,? super V> action)
      Specified by:
      forEach in interface Map<K extends ACell,V extends ACell>

    • print

      public boolean print(BlobBuilder sb, long limit)
      Description copied from class: AObject
      Prints this Object to a readable String Representation. SECURITY: Must halt and return false in O(1) time when limit of printing is exceeded otherwise DoS attacks may be possible.
      Specified by:
      print in class AObject
      Parameters:
      sb - BlobBuilder to append to. May be partially written if print limit exceeded
      limit - Limit of printing in string bytes
      Returns:
      True if fully printed within limit, false otherwise

    • assocEntry

      public abstract AMap<K,V> assocEntry(MapEntry<K,V> e)
      Associate the given map entry into the map. May return null if the map entry is not valid for this map type.
      Parameters:
      e - A map entry
      Returns:
      The updated map

    • entryAt

      public abstract MapEntry<K,V> entryAt(long i)
      Gets the entry in this map at a specified index, according to the map-specific order.
      Parameters:
      i - Index of entry
      Returns:
      MapEntry at the specified index.
      Throws:
      IndexOutOfBoundsException - If this index is not valid

    • getElementRef

      public Ref<MapEntry<K,V>> getElementRef(long index)
      Description copied from class: ACountable
      Gets a Ref to the element at the specified element index in this collection
      Specified by:
      getElementRef in class ACountable<MapEntry<K extends ACell,V extends ACell>>
      Parameters:
      index - Index of element to get
      Returns:
      Element at the specified index

    • get

      public final MapEntry<K,V> get(long i)
      Description copied from class: ACountable
      Gets the element at the specified element index in this collection
      Specified by:
      get in class ACountable<MapEntry<K extends ACell,V extends ACell>>
      Parameters:
      i - Index of element to get
      Returns:
      Element at the specified index

    • getEntry

      public abstract MapEntry<K,V> getEntry(ACell k)
      Gets the MapEntry for the given key
      Parameters:
      k - Key to lookup in Map
      Returns:
      The map entry, or null if the key is not found

    • get

      public V get(Object key)
      Specified by:
      get in interface Map<K extends ACell,V extends ACell>

    • get

      public abstract V get(ACell key)
      Description copied from class: ADataStructure
      Get the value associated with a given key.
      Specified by:
      get in class ADataStructure<MapEntry<K extends ACell,V extends ACell>>
      Parameters:
      key - Associative key to look up
      Returns:
      Value from collection, or a falsey value (null or false) if not found

    • get

      public final V get(ACell key, ACell notFound)
      Gets the value at a specified key, or returns the fallback value if not found
      Specified by:
      get in class ADataStructure<MapEntry<K extends ACell,V extends ACell>>
      Parameters:
      key - Key to lookup in Map
      notFound - Fallback value to return if key is not present
      Returns:
      Value for the specified key, or the notFound value.

    • reduceValues

      public abstract <R> R reduceValues(BiFunction<? super R,? super V,? extends R> func, R initial)
      Reduce over all values in this map
      Type Parameters:
      R - Type of reduction return value
      Parameters:
      func - A function taking the reduction value and a map value
      initial - Initial reduction value
      Returns:
      The final reduction value

    • filterValues

      public AMap<K,V> filterValues(Predicate<V> pred)
      Filters all values in this map with the given predicate.
      Parameters:
      pred - A predicate specifying which elements to retain.
      Returns:
      The updated map containing those entries where the predicate returned true.

    • reduceEntries

      public abstract <R> R reduceEntries(BiFunction<? super R,MapEntry<K,V>,? extends R> func, R initial)
      Reduce over all map entries in this map
      Type Parameters:
      R - Type of reduction return value
      Parameters:
      func - A function taking the reduction value and a map entry
      initial - Initial reduction value
      Returns:
      The final reduction value

    • keySet

      public Set<K> keySet()
      Specified by:
      keySet in interface Map<K extends ACell,V extends ACell>

    • getEntryByHash

      protected abstract MapEntry<K,V> getEntryByHash(Hash hash)
      Gets the map entry with the specified hash
      Parameters:
      hash - Hash of key to lookup
      Returns:
      The specified MapEntry, or null if not found.

    • conj

      public <R extends ACell> ADataStructure<R> conj(R x)
      Adds a new map entry to this map. The argument must be a valid map entry or length 2 vector.
      Specified by:
      conj in class ADataStructure<MapEntry<K extends ACell,V extends ACell>>
      Type Parameters:
      R - Type of Value added
      Parameters:
      x - An object that can be cast to a MapEntry
      Returns:
      Updated map with the specified entry added, or null if the argument is not a valid map entry

    • entryVector

      public AVector<MapEntry<K,V>> entryVector()
      Gets a vector of all map entries.
      Returns:
      Vector map entries, in map-defined order.

    • merge

      public AMap<K,V> merge(AMap<K,V> m)
      Merge another map into this map. Replaces existing entries if they are different. O(n) in size of map to merge. Preserves the type of the current map.
      Parameters:
      m - A map to merge into this map
      Returns:
      The updated map, or null if convesrion fails

    • slice

      public AMap<K,V> slice(long start)
      Description copied from class: ACountable
      Gets a slice of this data structure from start to the end
      Overrides:
      slice in class ACountable<MapEntry<K extends ACell,V extends ACell>>
      Parameters:
      start - Start index (inclusive)
      Returns:
      Slice of data structure, or null if invalid slice

    • slice

      public AMap<K,V> slice(long start, long end)
      Description copied from class: ACountable
      Gets a slice of this data structure
      Specified by:
      slice in class ACountable<MapEntry<K extends ACell,V extends ACell>>
      Parameters:
      start - Start index (inclusive)
      end - end index (exclusive)
      Returns:
      Slice of data structure, or null if invalid slice

    • getKeys

      public AVector<K> getKeys()
      Gets a vector of keys for this Map. O(n) in general.
      Returns:
      Vector of Keys