Package com.vladsch.flexmark.util.collection

Class OrderedMultiMap<K,V>

java.lang.Object

com.vladsch.flexmark.util.collection.OrderedMultiMap<K,V>

All Implemented Interfaces:

Iterable<Map.Entry<K,V>>, Map<K,V>

public class OrderedMultiMap<K,V>
extends Object
implements Map<K,V>, Iterable<Map.Entry<K,V>>

Nested Class Summary

Nested classes/interfaces inherited from interface java.util.Map

Map.Entry<K extends Object,V extends Object>

Constructor Summary

Constructors

Constructor	Description
OrderedMultiMap()
OrderedMultiMap(int capacity)
OrderedMultiMap(int capacity, @Nullable CollectionHost<com.vladsch.flexmark.util.misc.Paired<K,V>> host)
OrderedMultiMap(@NotNull CollectionHost<com.vladsch.flexmark.util.misc.Paired<K,V>> host)

Method Summary

Modifier and Type	Method	Description
void	addNullEntry(int index)
void	clear()
boolean	containsKey(@Nullable Object o)
boolean	containsValue(@Nullable Object o)
@NotNull OrderedSet<Map.Entry<K,V>>	entrySet()
ReversibleIterable<Map.Entry<K,V>>	entrySetIterable()
ReversibleIndexedIterator<Map.Entry<K,V>>	entrySetIterator()
boolean	equals(Object o)
void	forEach(Consumer<? super Map.Entry<K,V>> consumer)
V	get(@Nullable Object o)
Indexed<Map.Entry<K,V>>	getIndexedProxy()
K	getKey(int index)
V	getKeyValue(@Nullable Object o)
int	getModificationCount()
V	getValue(int index)
K	getValueKey(@Nullable Object o)
int	hashCode()
boolean	isEmpty()
@NotNull Iterator<Map.Entry<K,V>>	iterator()
ReversibleIterable<K>	keyIterable()
ReversibleIndexedIterator<K>	keyIterator()
Collection<K>	keys()
@NotNull OrderedSet<K>	keySet()
OrderedSet<Map.Entry<K,V>>	keyValueEntrySet()
V	put(K k, V v)
void	putAll(@NotNull Map<? extends K,? extends V> map)
void	putAllKeyValues(Map<? extends K,? extends V> map)
void	putAllValueKeys(Map<? extends V,? extends K> map)
boolean	putEntry(Map.Entry<K,V> e)
V	putKeyValue(K k, V v)
boolean	putKeyValueEntry(Map.Entry<K,V> e)
boolean	putKeyValuePair(@NotNull com.vladsch.flexmark.util.misc.Paired<K,V> e)
K	putValueKey(V v, K k)
boolean	putValueKeyEntry(Map.Entry<V,K> e)
boolean	putValueKeyPair(@NotNull com.vladsch.flexmark.util.misc.Paired<V,K> e)
V	remove(@Nullable Object o)
Map.Entry<K,V>	removeEntry(Map.Entry<K,V> e)
V	removeKey(Object o)
K	removeValue(Object o)
ReversibleIterable<Map.Entry<K,V>>	reversedEntrySetIterable()
ReversibleIndexedIterator<Map.Entry<K,V>>	reversedEntrySetIterator()
ReversibleIterable<K>	reversedKeyIterable()
ReversibleIndexedIterator<K>	reversedKeyIterator()
ReversibleIterable<V>	reversedValueIterable()
ReversibleIndexedIterator<V>	reversedValueIterator()
int	size()
ReversibleIterable<V>	valueIterable()
ReversibleIndexedIterator<V>	valueIterator()
@NotNull Collection<V>	values()
OrderedSet<V>	valueSet()

Methods inherited from class java.lang.Object

clone, finalize, getClass, notify, notifyAll, toString, wait, wait, wait

Methods inherited from interface java.lang.Iterable

spliterator

Methods inherited from interface java.util.Map

compute, computeIfAbsent, computeIfPresent, forEach, getOrDefault, merge, putIfAbsent, remove, replace, replace, replaceAll

Constructor Detail

OrderedMultiMap

public OrderedMultiMap()

OrderedMultiMap

public OrderedMultiMap(int capacity)

OrderedMultiMap

public OrderedMultiMap(@NotNull
                       @NotNull CollectionHost<com.vladsch.flexmark.util.misc.Paired<K,V>> host)

OrderedMultiMap

public OrderedMultiMap(int capacity,
                       @Nullable
                       @Nullable CollectionHost<com.vladsch.flexmark.util.misc.Paired<K,V>> host)

Method Detail

getIndexedProxy

public Indexed<Map.Entry<K,V>> getIndexedProxy()

getModificationCount

public int getModificationCount()

size

public int size()

Specified by:

size in interface Map<K,V>

isEmpty

public boolean isEmpty()

Specified by:

isEmpty in interface Map<K,V>

containsKey

public boolean containsKey(@Nullable
                           @Nullable Object o)

Specified by:

containsKey in interface Map<K,V>

containsValue

public boolean containsValue(@Nullable
                             @Nullable Object o)

Specified by:

containsValue in interface Map<K,V>

get

@Nullable
public V get(@Nullable
             @Nullable Object o)

Specified by:

get in interface Map<K,V>

getKeyValue

@Nullable
public V getKeyValue(@Nullable
                     @Nullable Object o)

getValueKey

@Nullable
public K getValueKey(@Nullable
                     @Nullable Object o)

put

@Nullable
public V put(@Nullable
             K k,
             @Nullable
             V v)

Specified by:

put in interface Map<K,V>

addNullEntry

public void addNullEntry(int index)

putEntry

public boolean putEntry(@NotNull
                        Map.Entry<K,V> e)

putKeyValueEntry

public boolean putKeyValueEntry(@NotNull
                                Map.Entry<K,V> e)

putValueKeyEntry

public boolean putValueKeyEntry(@NotNull
                                Map.Entry<V,K> e)

putKeyValuePair

public boolean putKeyValuePair(@NotNull
                               @NotNull com.vladsch.flexmark.util.misc.Paired<K,V> e)

putValueKeyPair

public boolean putValueKeyPair(@NotNull
                               @NotNull com.vladsch.flexmark.util.misc.Paired<V,K> e)

putKeyValue

public V putKeyValue(@Nullable
                     K k,
                     @Nullable
                     V v)

putValueKey

public K putValueKey(@Nullable
                     V v,
                     @Nullable
                     K k)

remove

@Nullable
public V remove(@Nullable
                @Nullable Object o)

Specified by:

remove in interface Map<K,V>

removeEntry

@Nullable
public Map.Entry<K,V> removeEntry(@NotNull
                                        Map.Entry<K,V> e)

removeKey

public V removeKey(Object o)

removeValue

public K removeValue(Object o)

putAll

public void putAll(@NotNull
                   @NotNull Map<? extends K,? extends V> map)

Specified by:

putAll in interface Map<K,V>

putAllKeyValues

public void putAllKeyValues(Map<? extends K,? extends V> map)

putAllValueKeys

public void putAllValueKeys(Map<? extends V,? extends K> map)

clear

public void clear()

Specified by:

clear in interface Map<K,V>

keySet

@NotNull
public @NotNull OrderedSet<K> keySet()

Specified by:

keySet in interface Map<K,V>

values

@NotNull
public @NotNull Collection<V> values()

Specified by:

values in interface Map<K,V>

valueSet

public OrderedSet<V> valueSet()

keys

public Collection<K> keys()

getKey

public K getKey(int index)

getValue

public V getValue(int index)

entrySet

@NotNull
public @NotNull OrderedSet<Map.Entry<K,V>> entrySet()

Specified by:

entrySet in interface Map<K,V>

valueIterator

public ReversibleIndexedIterator<V> valueIterator()

reversedValueIterator

public ReversibleIndexedIterator<V> reversedValueIterator()

valueIterable

public ReversibleIterable<V> valueIterable()

reversedValueIterable

public ReversibleIterable<V> reversedValueIterable()

keyIterator

public ReversibleIndexedIterator<K> keyIterator()

reversedKeyIterator

public ReversibleIndexedIterator<K> reversedKeyIterator()

keyIterable

public ReversibleIterable<K> keyIterable()

reversedKeyIterable

public ReversibleIterable<K> reversedKeyIterable()

entrySetIterator

public ReversibleIndexedIterator<Map.Entry<K,V>> entrySetIterator()

reversedEntrySetIterator

public ReversibleIndexedIterator<Map.Entry<K,V>> reversedEntrySetIterator()

entrySetIterable

public ReversibleIterable<Map.Entry<K,V>> entrySetIterable()

reversedEntrySetIterable

public ReversibleIterable<Map.Entry<K,V>> reversedEntrySetIterable()

iterator

@NotNull
public @NotNull Iterator<Map.Entry<K,V>> iterator()

Specified by:

iterator in interface Iterable<K>

forEach

public void forEach(Consumer<? super Map.Entry<K,V>> consumer)

Specified by:

forEach in interface Iterable<K>

keyValueEntrySet

public OrderedSet<Map.Entry<K,V>> keyValueEntrySet()

equals

public boolean equals(Object o)

Specified by:

equals in interface Map<K,V>

Overrides:

equals in class Object

hashCode

public int hashCode()

Specified by:

hashCode in interface Map<K,V>

Overrides:

hashCode in class Object