Package co.aikar.util

Class Table<R,C,V>

java.lang.Object

co.aikar.util.Table<R,C,V>

All Implemented Interfaces:

Iterable<Table.Entry<R,C,V>>

public class Table<R,C,V>
extends Object
implements Iterable<Table.Entry<R,C,V>>

Nested Class Summary

Nested Classes

Modifier and Type	Class	Description
static interface	Table.Entry<R,C,V>
static interface	Table.TableConsumer<R,C,V>
static interface	Table.TableFunction<R,C,V,RETURN>
static interface	Table.TablePredicate<R,C,V>

Constructor Summary

Constructors

Constructor	Description
Table()
Table(Supplier<Map<C,V>> columnMapSupplier)
Table(Map<R,Map<C,V>> backingRowMap, Function<R,Map<C,V>> columnMapSupplier)
Table(Map<R,Map<C,V>> backingRowMap, Supplier<Map<C,V>> columnMapSupplier)

Method Summary

Modifier and Type	Method	Description
V	compute(R row, C col, Table.TableFunction<R,C,V,V> function)
V	computeIfAbsent(R row, C col, BiFunction<R,C,V> function)
V	computeIfPresent(R row, C col, Table.TableFunction<R,C,V,V> function)
boolean	containsKey(R row, C col)
void	forEach(Table.TableConsumer<R,C,V> consumer)
void	forEach(Table.TablePredicate<R,C,V> predicate)
V	get(R row, C col)
V	getOrDefault(R row, C col, V def)
Iterator<Table.Entry<R,C,V>>	iterator()
V	merge(R row, C col, V val, Table.TableFunction<R,C,V,V> function)
V	put(R row, C col, V val)
V	remove(R row, C col)
void	removeIf(Table.TablePredicate<R,C,V> predicate)
V	replace(R row, C col, V val)
@org.jetbrains.annotations.Nullable boolean	replace(R row, C col, V old, V val)
void	replaceAll(Table.TableFunction<R,C,V,V> function)
Map<C,V>	row(R row)
Stream<Table.Entry<R,C,V>>	stream()
Stream<Table.Entry<R,C,V>>	stream(boolean parallel)

Methods inherited from class java.lang.Object

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

Methods inherited from interface java.lang.Iterable

forEach, spliterator

Constructor Detail

Table

public Table()

Table

public Table(Supplier<Map<C,V>> columnMapSupplier)

Table

public Table(Map<R,Map<C,V>> backingRowMap,
             Supplier<Map<C,V>> columnMapSupplier)

Table

public Table(Map<R,Map<C,V>> backingRowMap,
             Function<R,Map<C,V>> columnMapSupplier)

Method Detail

get

public V get(R row,
             C col)

getOrDefault

public V getOrDefault(R row,
                      C col,
                      V def)

containsKey

public boolean containsKey(R row,
                           C col)

put

@Nullable
public V put(R row,
             C col,
             V val)

forEach

public void forEach(Table.TableConsumer<R,C,V> consumer)

forEach

public void forEach(Table.TablePredicate<R,C,V> predicate)

removeIf

public void removeIf(Table.TablePredicate<R,C,V> predicate)

stream

public Stream<Table.Entry<R,C,V>> stream()

stream

public Stream<Table.Entry<R,C,V>> stream(boolean parallel)

iterator

public Iterator<Table.Entry<R,C,V>> iterator()

Specified by:

iterator in interface Iterable<R>

replaceAll

public void replaceAll(Table.TableFunction<R,C,V,V> function)

remove

public V remove(R row,
                C col)

replace

@Nullable
public V replace(R row,
                 C col,
                 V val)

replace

@Nullable
public @org.jetbrains.annotations.Nullable boolean replace(R row,
                                                           C col,
                                                           V old,
                                                           V val)

computeIfAbsent

public V computeIfAbsent(R row,
                         C col,
                         BiFunction<R,C,V> function)

computeIfPresent

public V computeIfPresent(R row,
                          C col,
                          Table.TableFunction<R,C,V,V> function)

compute

public V compute(R row,
                 C col,
                 Table.TableFunction<R,C,V,V> function)

merge

public V merge(R row,
               C col,
               V val,
               Table.TableFunction<R,C,V,V> function)

row

public Map<C,V> row(R row)