const classafConcurrent::SynchronizedMap

sys::Obj
  afConcurrent::SynchronizedMap

A Map that provides fast reads and synchronised writes between threads, ensuring data integrity.

The map is stored in an AtomicRef through which all reads are made.

All write operations ( getOrAdd, set, remove & clear ) are made via synchronized blocks ensuring no data is lost during race conditions. Writing makes a rw copy of the map and is thus a more expensive operation.

All values held in the map must be immutable.

caseInsensitive

const Bool caseInsensitive := false

Configures case sensitivity for maps with Str keys.

clear

This clear()

Remove all key/value pairs from the map. Return this.

containsKey

Bool containsKey(Obj key)

Returns true if the map contains the given key

def

const Obj? def := null

The default value to use for get when a key isn't mapped.

each

Void each(|Obj?,Obj c)

Call the specified function for every key/value in the map.

get

@Operator Obj? get(Obj key, Obj? def := this.def)

Returns the value associated with the given key. If key is not mapped, then return the value of the def parameter. If def is omitted it defaults to null.

getOrAdd

Obj? getOrAdd(Obj key, |Obj->Obj? valFunc)

Returns the value associated with the given key. If it doesn't exist then it is added from the value function.

This method is thread safe. valFunc will not be called twice for the same key.

Note that valFunc should be immutable and, if used, is executed in a different thread to the calling thread.

isEmpty

Bool isEmpty()

Return true if size() == 0

keyType

const Type keyType := sys::Obj#

Used to parameterize the backing map. Must be non-nullable.

keys

Obj[] keys()

Returns a list of all the mapped keys.

lock

const Synchronized lock

The lock object should you need to synchronize on the Map.

make

new make(ActorPool actorPool, |This? f := null)

Creates a SynchronizedMap with the given ActorPool.

ordered

const Bool ordered := false

If true the map will maintain the order in which key/value pairs are added.

remove

Obj? remove(Obj key)

Remove the key/value pair identified by the specified key from the map and return the value. If the key was not mapped then return null.

rw

Obj:Obj? rw()

Get a read-write, mutable Map instance with the same contents.

set

@Operator Void set(Obj key, Obj? item)

Sets the key / value pair, ensuring no data is lost during multi-threaded race conditions. Both the key and val must be immutable.

size

Int size()

Get the number of key/value pairs in the map.

toStr

virtual override Str toStr()

Returns a string representation the map.

val

Obj:Obj? val

Gets or sets a read-only copy of the backing map.

valType

const Type valType := sys::Obj?#

Used to parameterize the backing map.

vals

Obj?[] vals()

Returns a list of all the mapped values.