AuthorisedChronicleQueueView (ChronicleEnterprise/Chronicle-Datagrid 2.21ea41-SNAPSHOT API)

java.lang.Object
- software.chronicle.datagrid.internal.queue.AuthorisedChronicleQueueView<T,M>

All Implemented Interfaces:

Closeable, AutoCloseable, ConcurrentMap<T,M>, Function<T,M>, Map<T,M>, net.openhft.chronicle.core.io.QueryCloseable, KeyedVisitable<T,M>, Updatable<MapView<T,M>>, MapView<T,M>, TopicPublisher<T,M>, QueueView<T,M>, Assetted<Object>, KeyedView, SubAssetFactory
```
public final class AuthorisedChronicleQueueView<T,M>
extends Object
implements QueueView<T,M>, MapView<T,M>, SubAssetFactory, Closeable
```

Nested Class Summary
- Nested classes/interfaces inherited from interface software.chronicle.datagrid.queue.QueueView
  QueueView.Excerpt<T,M>, QueueView.Tailer<T,M>
- Nested classes/interfaces inherited from interface java.util.Map
  Map.Entry<K,V>

Constructor Summary

Constructors
Constructor and Description
`AuthorisedChronicleQueueView(@NotNull RequestContext context, @NotNull Asset asset, @NotNull ChronicleQueueView<T,M> queueView)`

Method Summary

All Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`<V> @NotNull Function<T,V>`	`andThen(@NotNull Function<? super M,? extends V> after)`
`M`	`apply(T t)`
`<A,R> R`	`applyTo(@NotNull net.openhft.chronicle.core.util.SerializableBiFunction<MapView<T,M>,A,R> function, A arg)` Apply a function to an Updatable which is assumed to not change the visited in any significant way.
`<R> R`	`applyTo(@NotNull net.openhft.chronicle.core.util.SerializableFunction<MapView<T,M>,R> function)` Apply a function to an Updatable which is assumed to not change the visited in any significant way.
`<T1,R> R`	`applyToKey(T key, @NotNull net.openhft.chronicle.core.util.SerializableBiFunction<M,T1,R> function, T1 argument)` Apply a function which takes an argument.
`<R> R`	`applyToKey(T key, @NotNull net.openhft.chronicle.core.util.SerializableFunction<M,R> function)` Apply a function to the visitable and return the result.
`Asset`	`asset()`
`void`	`asyncUpdate(@NotNull net.openhft.chronicle.core.util.SerializableUpdater<MapView<T,M>> updateFunction)` Update an Updatable potentially asynchronously.
`<A> void`	`asyncUpdate(@NotNull net.openhft.chronicle.core.util.SerializableUpdaterWithArg<MapView<T,M>,A> updateFunction, A arg)` Update an Updatable potentially asynchronously.
`<T1> void`	`asyncUpdateKey(T key, @NotNull net.openhft.chronicle.core.util.SerializableBiFunction<M,T1,M> updateFunction, T1 argument)` Apply a function to visitable potentially asynchronously.
`void`	`asyncUpdateKey(T key, @NotNull net.openhft.chronicle.core.util.SerializableFunction<M,M> updateFunction)` Apply a function to visitable potentially asynchronously.
`void`	`clear()`
`void`	`close()`
`<V> @NotNull Function<V,M>`	`compose(@NotNull Function<? super V,? extends T> before)`
`M`	`compute(T key, BiFunction<? super T,? super M,? extends M> remappingFunction)`
`M`	`computeIfAbsent(T key, Function<? super T,? extends M> mappingFunction)`
`M`	`computeIfPresent(T key, BiFunction<? super T,? super M,? extends M> remappingFunction)`
`boolean`	`containsKey(Object key)`
`boolean`	`containsValue(Object value)`
`<E> @Nullable Asset`	`createSubAsset(@NotNull VanillaAsset vanillaAsset, String name, Class<E> valueType)`
`@NotNull EntrySetView<T,M>`	`entrySet()`
`boolean`	`equals(Object o)`
`@Nullable QueueView.Excerpt<T,M>`	`excerpt(long index)` Returns the `QueueView.Excerpt` at a given `index` or `null` if no such Excerpt exists.
`void`	`forEach(BiConsumer<? super T,? super M> action)`
`M`	`get(Object key)`
`M`	`getAndPut(T key, M value)` Explicitly get the old value before putting a new one.
`M`	`getAndRemove(T key)` Explicitly get the old value before removing.
`M`	`getOrDefault(Object key, M defaultValue)`
`M`	`getUsing(T key, Object using)` Obtain a value using a mutable buffer provided.
`int`	`hashCode()`
`boolean`	`isClosed()`
`boolean`	`isEmpty()`
`boolean`	`keyedView()` Returns if this is a keyed asset, i.e.
`@NotNull KeySetView<T>`	`keySet()`
`Class<T>`	`keyType()`
`long`	`longSize()`
`M`	`merge(T key, M value, BiFunction<? super M,? super M,? extends M> remappingFunction)`
`QueueView.Excerpt<T,M>`	`next(long index)` Returns the `QueueView.Excerpt` immediately following the Excerpt at a given `index` or `null` if no such Excerpt exists.
`@Nullable QueueView.Excerpt<T,M>`	`next(T topic)` Returns the next unread message from the tailer with the provided `topic` or `null` if no such Excerpt exists.
`void`	`notifyClosing()`
`void`	`publish(T topic, M message)` Publish the given `message` to the provided `topic`.
`long`	`publishAndIndex(T topic, M message)` Publish the given `message` to the provided `topic`.
`@NotNull Publisher<M>`	`publisher(T topic)` Creates and returns a new Publisher for the provided `topic`.
`M`	`put(T key, M value)`
`void`	`putAll(@NotNull Map<? extends T,? extends M> m)`
`M`	`putIfAbsent(T key, M value)`
`Reference<M>`	`referenceFor(T key)` Obtain a reference the value for a key
`void`	`registerKeySubscriber(@NotNull Subscriber<? super T> subscriber)` Add a Subscription for the keys changed on this Map
`void`	`registerKeySubscriber(@NotNull Subscriber<? super T> subscriber, @NotNull Filter filter, @NotNull Set<RequestContext.Operation> contextOperations)` Add a Subscription for the keys changed on this Map
`void`	`registerSubscriber(@NotNull Subscriber<? extends MapEvent<? super T,? super M>> subscriber)` Add a Subscription for the MapEvents triggered by changes on this Map.
`void`	`registerSubscriber(@NotNull Subscriber<? extends MapEvent<? super T,? super M>> subscriber, @NotNull Filter<? extends MapEvent<? super T,? super M>> filter, @NotNull Set<RequestContext.Operation> contextOperations)` Add a Subscription for the MapEvents triggered by changes on this Map.
`void`	`registerSubscriber(T topic, @NotNull Subscriber<? super M> subscriber)` Registers and associates the provided `subscriber` with the provided `topic`.
`void`	`registerTopicSubscriber(@NotNull TopicSubscriber<? super T,? super M> topicSubscriber)` Add a subscription to this group.
`M`	`remove(Object key)`
`boolean`	`remove(@NotNull Object key, Object value)`
`M`	`replace(T key, M value)`
`boolean`	`replace(T key, M oldValue, M newValue)`
`void`	`replaceAll(BiFunction<? super T,? super M,? extends M> function)`
`void`	`set(T key, M element)`
`int`	`size()`
`<R> R`	`syncUpdate(@NotNull net.openhft.chronicle.core.util.SerializableUpdater<MapView<T,M>> updateFunction, @NotNull net.openhft.chronicle.core.util.SerializableFunction<MapView<T,M>,R> returnFunction)` Apply a function to update an Updatable and apply a second function to derive some information from it.
`<UA,RA,R> R`	`syncUpdate(@NotNull net.openhft.chronicle.core.util.SerializableUpdaterWithArg<MapView<T,M>,UA> updateFunction, UA ua, @NotNull net.openhft.chronicle.core.util.SerializableBiFunction<MapView<T,M>,RA,R> returnFunction, RA returnArgument)` Apply a function to update an Updatable and apply a second function to derive some information from it.
`<T1,A,R> R`	`syncUpdateKey(T key, @NotNull net.openhft.chronicle.core.util.SerializableBiFunction<M,T1,M> updateFunction, T1 updateArgument, @NotNull net.openhft.chronicle.core.util.SerializableBiFunction<M,A,R> returnFunction, A returnArgument)` Apply a function to update the state of a visible, and apply a function to return a result object synchronously.
`<R> R`	`syncUpdateKey(T key, @NotNull net.openhft.chronicle.core.util.SerializableFunction<M,M> updateFunction, @NotNull net.openhft.chronicle.core.util.SerializableFunction<M,R> returnFunction)` Apply a function to update the state of a visible, and apply a function to return a result object synchronously.
`void`	`throwExceptionIfClosed()`
`@Nullable Object`	`underlying()`
`void`	`unregisterSubscriber(T topic, @NotNull Subscriber<? super M> subscriber)` Unregisters and disassociates the provided `subscriber` from the provided `topic`.
`void`	`unregisterTopicSubscriber(@NotNull TopicSubscriber<? super T,? super M> topicSubscriber)` Unregister a TopicSubscriber
`void`	`unregisterTopicSubscriber(T topic, @NotNull TopicSubscriber<? super T,? super M> topicSubscriber)`
`@NotNull Collection<M>`	`values()`
`Class<M>`	`valueType()`

Methods inherited from class java.lang.Object
clone, finalize, getClass, notify, notifyAll, toString, wait, wait, wait

Methods inherited from interface software.chronicle.datagrid.pubsub.TopicPublisher
registerTopicSubscriber

Methods inherited from interface net.openhft.chronicle.core.io.Closeable
closeQuietly, closeQuietly, warnAndCloseIfNotClosed

Methods inherited from interface net.openhft.chronicle.core.io.QueryCloseable
isClosing

Methods inherited from interface java.util.function.Function
identity

- Constructor Detail
  - AuthorisedChronicleQueueView
```
public AuthorisedChronicleQueueView(@NotNull
                                    @NotNull RequestContext context,
                                    @NotNull
                                    @NotNull Asset asset,
                                    @NotNull
                                    @NotNull ChronicleQueueView<T,M> queueView)
```
- Method Detail
  - keySet
```
@NotNull
public @NotNull KeySetView<T> keySet()
```
    Specified by:
    
    keySet in interface Map<T,M>
    
    Specified by:
    
    keySet in interface MapView<T,M>
  - throwExceptionIfClosed
```
public void throwExceptionIfClosed()
```
    Specified by:
    
    throwExceptionIfClosed in interface net.openhft.chronicle.core.io.QueryCloseable
  - values
```
@NotNull
public @NotNull Collection<M> values()
```
    Specified by:
    
    values in interface Map<T,M>
  - entrySet
```
@NotNull
public @NotNull EntrySetView<T,M> entrySet()
```
    Specified by:
    
    entrySet in interface Map<T,M>
    
    Specified by:
    
    entrySet in interface MapView<T,M>
  - getUsing
```
@NotNull
public M getUsing(T key,
                           Object using)
```
    Description copied from interface: MapView
    
    Obtain a value using a mutable buffer provided.
    
    Specified by:
    
    getUsing in interface MapView<T,M>
    
    Parameters:
    
    key - to lookup.
    
    using - a mutable buffer
    
    Returns:
    
    the value.
  - registerTopicSubscriber
```
public void registerTopicSubscriber(@NotNull
                                    @NotNull TopicSubscriber<? super T,? super M> topicSubscriber)
```
    Description copied from interface: TopicPublisher
    
    Add a subscription to this group.
    Any given instance of a subscriber must at most be registered once with a DataGrid instance at any given time.
    This method is asynchronous and the provided subscriber will be eligible for receiving events as some later unspecified time.
    
    Specified by:
    
    registerTopicSubscriber in interface MapView<T,M>
    
    Specified by:
    
    registerTopicSubscriber in interface TopicPublisher<T,M>
    
    Parameters:
    
    topicSubscriber - to listen to events.
  - unregisterTopicSubscriber
```
public void unregisterTopicSubscriber(@NotNull
                                      @NotNull TopicSubscriber<? super T,? super M> topicSubscriber)
```
    Description copied from interface: TopicPublisher
    
    Unregister a TopicSubscriber
    This method is asynchronous and the provided subscriber will be prevented from receiving events as some later unspecified time.
    
    Specified by:
    
    unregisterTopicSubscriber in interface TopicPublisher<T,M>
    
    Parameters:
    
    topicSubscriber - to unregister
  - registerKeySubscriber
```
public void registerKeySubscriber(@NotNull
                                  @NotNull Subscriber<? super T> subscriber)
```
    Description copied from interface: MapView
    
    Add a Subscription for the keys changed on this Map
    Any given instance of a subscriber must at most be registered once with a DataGrid instance at any given time.
    This method is asynchronous and the provided subscriber will be eligible for receiving events as some later unspecified time.
    
    Specified by:
    
    registerKeySubscriber in interface MapView<T,M>
    
    Parameters:
    
    subscriber - to add
  - registerKeySubscriber
```
public void registerKeySubscriber(@NotNull
                                  @NotNull Subscriber<? super T> subscriber,
                                  @NotNull
                                  @NotNull Filter filter,
                                  @NotNull
                                  @NotNull Set<RequestContext.Operation> contextOperations)
```
    Description copied from interface: MapView
    
    Add a Subscription for the keys changed on this Map
    Any given instance of a subscriber must at most be registered once with a DataGrid instance at any given time.
    This method is asynchronous and the provided subscriber will be eligible for receiving events as some later unspecified time.
    
    Specified by:
    
    registerKeySubscriber in interface MapView<T,M>
    
    Parameters:
    
    subscriber - to add
    
    filter - a list of filter operations
    
    contextOperations - which optional operations to consider (e.g. bootstrap and ending after bootstrap)
  - registerSubscriber
```
public void registerSubscriber(@NotNull
                               @NotNull Subscriber<? extends MapEvent<? super T,? super M>> subscriber,
                               @NotNull
                               @NotNull Filter<? extends MapEvent<? super T,? super M>> filter,
                               @NotNull
                               @NotNull Set<RequestContext.Operation> contextOperations)
```
    Description copied from interface: MapView
    
    Add a Subscription for the MapEvents triggered by changes on this Map.
    Any given instance of a subscriber must at most be registered once with a DataGrid instance at any given time.
    This method is asynchronous and the provided subscriber will be eligible for receiving events as some later unspecified time.
    
    Specified by:
    
    registerSubscriber in interface MapView<T,M>
    
    Parameters:
    
    subscriber - the subscriber to the subscription
    
    filter - to apply on keys and values
    
    contextOperations - which optional operations to consider (e.g. bootstrap and ending after bootstrap)
  - unregisterSubscriber
```
public void unregisterSubscriber(@NotNull
                                 T topic,
                                 @NotNull
                                 @NotNull Subscriber<? super M> subscriber)
```
    Description copied from interface: TopicPublisher
    
    Unregisters and disassociates the provided subscriber from the provided topic.
    This method is asynchronous and the provided subscriber will be prevented from receiving events as some later unspecified time.
    
    Specified by:
    
    unregisterSubscriber in interface TopicPublisher<T,M>
    
    Parameters:
    
    topic - to disassociates from the given subscriber
    
    subscriber - to unregister
  - referenceFor
```
public Reference<M> referenceFor(T key)
```
    Description copied from interface: MapView
    
    Obtain a reference the value for a key
    
    Specified by:
    
    referenceFor in interface MapView<T,M>
    
    Parameters:
    
    key - to bind the reference to
    
    Returns:
    
    a reference object.
  - keyType
```
public Class<T> keyType()
```
    Specified by:
    
    keyType in interface MapView<T,M>
    
    Returns:
    
    the type of the keys
  - valueType
```
public Class<M> valueType()
```
    Specified by:
    
    valueType in interface MapView<T,M>
    
    Returns:
    
    the type of the values.
  - longSize
```
public long longSize()
```
    Specified by:
    
    longSize in interface MapView<T,M>
    
    Returns:
    
    the size as a long value.
  - getAndPut
```
@Nullable
public M getAndPut(T key,
                             M value)
```
    Description copied from interface: MapView
    
    Explicitly get the old value before putting a new one.
    
    Specified by:
    
    getAndPut in interface MapView<T,M>
    
    Parameters:
    
    key - to lookup
    
    value - to set
    
    Returns:
    
    the old value or null if absent
  - getAndRemove
```
@Nullable
public M getAndRemove(T key)
```
    Description copied from interface: MapView
    
    Explicitly get the old value before removing.
    
    Specified by:
    
    getAndRemove in interface MapView<T,M>
    
    Parameters:
    
    key - to remove
    
    Returns:
    
    the old value or null if absent.
  - unregisterTopicSubscriber
```
public void unregisterTopicSubscriber(@NotNull
                                      T topic,
                                      @NotNull
                                      @NotNull TopicSubscriber<? super T,? super M> topicSubscriber)
```
  - publisher
```
@NotNull
public @NotNull Publisher<M> publisher(@NotNull
                                                T topic)
```
    Description copied from interface: TopicPublisher
    
    Creates and returns a new Publisher for the provided topic.
    
    Specified by:
    
    publisher in interface TopicPublisher<T,M>
    
    Parameters:
    
    topic - to create a Publisher for
    
    Returns:
    
    a new Publisher for the provided topic
  - registerSubscriber
```
public void registerSubscriber(@NotNull
                               T topic,
                               @NotNull
                               @NotNull Subscriber<? super M> subscriber)
```
    Description copied from interface: TopicPublisher
    
    Registers and associates the provided subscriber with the provided topic.
    Any given instance of a subscriber must at most be registered once with a DataGrid instance at any given time.
    This method is asynchronous and the provided subscriber will be eligible for receiving events as some later unspecified time.
    
    Specified by:
    
    registerSubscriber in interface TopicPublisher<T,M>
    
    Parameters:
    
    topic - to associate with the given subscriber
    
    subscriber - to register
  - excerpt
```
@Nullable
public @Nullable QueueView.Excerpt<T,M> excerpt(long index)
```
    Description copied from interface: QueueView
    
    Returns the QueueView.Excerpt at a given index or null if no such Excerpt exists.
    If the provided index is 0, then the excerpt at the first index is returned
    If the index is not a valid index, the operation is undefined.
    The Excerpt object returned may be reused between invocations of methods provided by a QueueView.
    
    Specified by:
    
    excerpt in interface QueueView<T,M>
    
    Parameters:
    
    index - the address of the except
    
    Returns:
    
    the QueueView.Excerpt at a given index or null if no such Excerpt exists
  - next
```
public QueueView.Excerpt<T,M> next(long index)
```
    Description copied from interface: QueueView
    
    Returns the QueueView.Excerpt immediately following the Excerpt at a given index or null if no such Excerpt exists. This method is useful for continuously reading Excerpts in an environment where the client can switch between several servers.
    In other words, assuming that the queue has not rolled, returns an excerpt who's index is the provided index + 1
    If the provided index is 0, then the excerpt at the second index is returned
    If the index is not a valid index, the operation is undefined.
    The Excerpt object returned may be reused between invocations of methods provided by a QueueView.
    
    Specified by:
    
    next in interface QueueView<T,M>
    
    Parameters:
    
    index - the address of a previous except for which the next Excerpt is to be retrieved
    
    Returns:
    
    the QueueView.Excerpt immediately following the Excerpt at a given index or null if no such Excerpt exists
  - next
```
@Nullable
public @Nullable QueueView.Excerpt<T,M> next(@NotNull
                                                       T topic)
```
    Description copied from interface: QueueView
    
    Returns the next unread message from the tailer with the provided topic or null if no such Excerpt exists.
    The Excerpt object returned may be reused between invocations of methods provided by a QueueView.
    
    Specified by:
    
    next in interface QueueView<T,M>
    
    Parameters:
    
    topic - for which the next excerpt shall be returned.
    
    Returns:
    
    the next unread message from the tailer with the provided topic or null if no such Excerpt exists
  - set
```
public void set(T key,
                M element)
```
    Specified by:
    
    set in interface KeyedVisitable<T,M>
    
    Parameters:
    
    key - to set within this collection.
    
    element - replace the current state of the visitable Asset
  - publish
```
public void publish(@NotNull
                    T topic,
                    @NotNull
                    M message)
```
    Description copied from interface: TopicPublisher
    
    Publish the given message to the provided topic.
    
    Specified by:
    
    publish in interface TopicPublisher<T,M>
    
    Parameters:
    
    topic - to publish to
    
    message - to publish.
  - publishAndIndex
```
public long publishAndIndex(@NotNull
                            T topic,
                            @Nullable
                            M message)
```
    Description copied from interface: QueueView
    
    Publish the given message to the provided topic.
    
    Specified by:
    
    publishAndIndex in interface QueueView<T,M>
    
    Parameters:
    
    topic - to publish to
    
    message - to publish.
    
    Returns:
    
    the index in the chronicle queue that the message was written or 0, if this information is not available
  - isEmpty
```
public boolean isEmpty()
```
    Specified by:
    
    isEmpty in interface Map<T,M>
  - containsKey
```
public boolean containsKey(Object key)
```
    Specified by:
    
    containsKey in interface Map<T,M>
  - containsValue
```
public boolean containsValue(Object value)
```
    Specified by:
    
    containsValue in interface Map<T,M>
  - put
```
@Nullable
public M put(T key,
                       M value)
```
    Specified by:
    
    put in interface Map<T,M>
  - remove
```
public M remove(Object key)
```
    Specified by:
    
    remove in interface Map<T,M>
  - putAll
```
public void putAll(@NotNull
                   @NotNull Map<? extends T,? extends M> m)
```
    Specified by:
    
    putAll in interface Map<T,M>
  - clear
```
public void clear()
```
    Specified by:
    
    clear in interface Map<T,M>
  - close
```
public void close()
```
    Specified by:
    
    close in interface Closeable
    
    Specified by:
    
    close in interface AutoCloseable
  - registerSubscriber
```
public void registerSubscriber(@NotNull
                               @NotNull Subscriber<? extends MapEvent<? super T,? super M>> subscriber)
```
    Description copied from interface: MapView
    
    Add a Subscription for the MapEvents triggered by changes on this Map.
    Any given instance of a subscriber must at most be registered once with a DataGrid instance at any given time.
    This method is asynchronous and the provided subscriber will be eligible for receiving events as some later unspecified time.
    
    Specified by:
    
    registerSubscriber in interface MapView<T,M>
    
    Parameters:
    
    subscriber - the subscriber to the subscription
  - createSubAsset
```
@Nullable
public <E> @Nullable Asset createSubAsset(@NotNull
                                                    @NotNull VanillaAsset vanillaAsset,
                                                    String name,
                                                    Class<E> valueType)
```
    Specified by:
    
    createSubAsset in interface SubAssetFactory
  - putIfAbsent
```
public M putIfAbsent(@NotNull
                     T key,
                     M value)
```
    Specified by:
    
    putIfAbsent in interface ConcurrentMap<T,M>
    
    Specified by:
    
    putIfAbsent in interface Map<T,M>
  - remove
```
public boolean remove(@NotNull
                      @NotNull Object key,
                      Object value)
```
    Specified by:
    
    remove in interface ConcurrentMap<T,M>
    
    Specified by:
    
    remove in interface Map<T,M>
  - replace
```
public boolean replace(@NotNull
                       T key,
                       @NotNull
                       M oldValue,
                       @NotNull
                       M newValue)
```
    Specified by:
    
    replace in interface ConcurrentMap<T,M>
    
    Specified by:
    
    replace in interface Map<T,M>
  - replace
```
public M replace(@NotNull
                 T key,
                 @NotNull
                 M value)
```
    Specified by:
    
    replace in interface ConcurrentMap<T,M>
    
    Specified by:
    
    replace in interface Map<T,M>
  - asset
```
public Asset asset()
```
    Specified by:
    
    asset in interface Assetted<Object>
    
    Returns:
    
    The Asset this resource is associated with.
  - underlying
```
@Nullable
public @Nullable Object underlying()
```
    Specified by:
    
    underlying in interface Assetted<Object>
    
    Returns:
    
    The Underlying view this view is built on.
  - keyedView
```
public boolean keyedView()
```
    Description copied from interface: KeyedView
    
    Returns if this is a keyed asset, i.e. anything under this must be a SubAsset
    
    Specified by:
    
    keyedView in interface KeyedView
    
    Returns:
    
    if this is a keyed asset, i.e. anything under this must be a SubAsset
  - apply
```
@Nullable
public M apply(T t)
```
    Specified by:
    
    apply in interface Function<T,M>
    
    Specified by:
    
    apply in interface MapView<T,M>
  - size
```
public int size()
```
    Specified by:
    
    size in interface Map<T,M>
    
    Specified by:
    
    size in interface MapView<T,M>
  - getOrDefault
```
public M getOrDefault(Object key,
                      M defaultValue)
```
    Specified by:
    
    getOrDefault in interface ConcurrentMap<T,M>
    
    Specified by:
    
    getOrDefault in interface Map<T,M>
  - forEach
```
public void forEach(BiConsumer<? super T,? super M> action)
```
    Specified by:
    
    forEach in interface ConcurrentMap<T,M>
    
    Specified by:
    
    forEach in interface Map<T,M>
  - replaceAll
```
public void replaceAll(BiFunction<? super T,? super M,? extends M> function)
```
    Specified by:
    
    replaceAll in interface ConcurrentMap<T,M>
    
    Specified by:
    
    replaceAll in interface Map<T,M>
  - computeIfAbsent
```
public M computeIfAbsent(T key,
                         Function<? super T,? extends M> mappingFunction)
```
    Specified by:
    
    computeIfAbsent in interface ConcurrentMap<T,M>
    
    Specified by:
    
    computeIfAbsent in interface Map<T,M>
  - computeIfPresent
```
public M computeIfPresent(T key,
                          BiFunction<? super T,? super M,? extends M> remappingFunction)
```
    Specified by:
    
    computeIfPresent in interface ConcurrentMap<T,M>
    
    Specified by:
    
    computeIfPresent in interface Map<T,M>
  - compute
```
public M compute(T key,
                 BiFunction<? super T,? super M,? extends M> remappingFunction)
```
    Specified by:
    
    compute in interface ConcurrentMap<T,M>
    
    Specified by:
    
    compute in interface Map<T,M>
  - merge
```
public M merge(T key,
               M value,
               BiFunction<? super M,? super M,? extends M> remappingFunction)
```
    Specified by:
    
    merge in interface ConcurrentMap<T,M>
    
    Specified by:
    
    merge in interface Map<T,M>
  - equals
```
public boolean equals(Object o)
```
    Specified by:
    
    equals in interface Map<T,M>
    
    Overrides:
    
    equals in class Object
  - hashCode
```
public int hashCode()
```
    Specified by:
    
    hashCode in interface Map<T,M>
    
    Overrides:
    
    hashCode in class Object
  - applyTo
```
@Nullable
public <R> R applyTo(@NotNull
                               @NotNull net.openhft.chronicle.core.util.SerializableFunction<MapView<T,M>,R> function)
```
    Description copied from interface: Updatable
    
    Apply a function to an Updatable which is assumed to not change the visited in any significant way. This might not trigger an event.
    
    Specified by:
    
    applyTo in interface Updatable<MapView<T,M>>
    
    Type Parameters:
    
    R - return type.
    
    Parameters:
    
    function - to apply to derive data from this Updatable.
    
    Returns:
    
    derived data.
  - asyncUpdate
```
public void asyncUpdate(@NotNull
                        @NotNull net.openhft.chronicle.core.util.SerializableUpdater<MapView<T,M>> updateFunction)
```
    Description copied from interface: Updatable
    
    Update an Updatable potentially asynchronously. This function is assumed to update Updatable.
    
    Specified by:
    
    asyncUpdate in interface Updatable<MapView<T,M>>
    
    Parameters:
    
    updateFunction - to apply.
  - syncUpdate
```
@Nullable
public <R> R syncUpdate(@NotNull
                                  @NotNull net.openhft.chronicle.core.util.SerializableUpdater<MapView<T,M>> updateFunction,
                                  @NotNull
                                  @NotNull net.openhft.chronicle.core.util.SerializableFunction<MapView<T,M>,R> returnFunction)
```
    Description copied from interface: Updatable
    
    Apply a function to update an Updatable and apply a second function to derive some information from it.
    
    Specified by:
    
    syncUpdate in interface Updatable<MapView<T,M>>
    
    Type Parameters:
    
    R - data type to return.
    
    Parameters:
    
    updateFunction - to apply the update.
    
    returnFunction - to derive some data
    
    Returns:
    
    value derived.
  - applyTo
```
@Nullable
public <A,R> R applyTo(@NotNull
                                 @NotNull net.openhft.chronicle.core.util.SerializableBiFunction<MapView<T,M>,A,R> function,
                                 A arg)
```
    Description copied from interface: Updatable
    
    Apply a function to an Updatable which is assumed to not change the visited in any significant way. This might not trigger an event.
    
    Specified by:
    
    applyTo in interface Updatable<MapView<T,M>>
    
    Type Parameters:
    
    A - argument type.
    
    R - return type.
    
    Parameters:
    
    function - to apply to derive data from this Updatable.
    
    arg - argument to apply
    
    Returns:
    
    derived data.
  - asyncUpdate
```
public <A> void asyncUpdate(@NotNull
                            @NotNull net.openhft.chronicle.core.util.SerializableUpdaterWithArg<MapView<T,M>,A> updateFunction,
                            A arg)
```
    Description copied from interface: Updatable
    
    Update an Updatable potentially asynchronously. This function is assumed to update Updatable.
    
    Specified by:
    
    asyncUpdate in interface Updatable<MapView<T,M>>
    
    Type Parameters:
    
    A - argument type.
    
    Parameters:
    
    updateFunction - to apply.
    
    arg - argument to apply
  - syncUpdate
```
@Nullable
public <UA,RA,R> R syncUpdate(@NotNull
                                        @NotNull net.openhft.chronicle.core.util.SerializableUpdaterWithArg<MapView<T,M>,UA> updateFunction,
                                        UA ua,
                                        @NotNull
                                        @NotNull net.openhft.chronicle.core.util.SerializableBiFunction<MapView<T,M>,RA,R> returnFunction,
                                        RA returnArgument)
```
    Description copied from interface: Updatable
    
    Apply a function to update an Updatable and apply a second function to derive some information from it.
    
    Specified by:
    
    syncUpdate in interface Updatable<MapView<T,M>>
    
    Type Parameters:
    
    UA - update argument type
    
    RA - return argument type
    
    R - return type
    
    Parameters:
    
    updateFunction - to apply the update.
    
    ua - update argument
    
    returnFunction - to derive some data
    
    returnArgument - return argument
    
    Returns:
    
    a value derived from applying the provided parameters
  - get
```
@Nullable
public M get(Object key)
```
    Specified by:
    
    get in interface Map<T,M>
    
    Specified by:
    
    get in interface KeyedVisitable<T,M>
    
    Parameters:
    
    key - to get within this collection.
    
    Returns:
    
    the current state of a visitable Asset
  - applyToKey
```
@Nullable
public <R> R applyToKey(T key,
                                  @NotNull
                                  @NotNull net.openhft.chronicle.core.util.SerializableFunction<M,R> function)
```
    Description copied from interface: KeyedVisitable
    
    Apply a function to the visitable and return the result. This function is assumed to not change the value in any significant way.
    
    Specified by:
    
    applyToKey in interface KeyedVisitable<T,M>
    
    Type Parameters:
    
    R - data type to return.
    
    Parameters:
    
    key - to visit within this collection.
    
    function - to apply e.g. call a getter
    
    Returns:
    
    the result of the code called.
  - asyncUpdateKey
```
public void asyncUpdateKey(T key,
                           @NotNull
                           @NotNull net.openhft.chronicle.core.util.SerializableFunction<M,M> updateFunction)
```
    Description copied from interface: KeyedVisitable
    
    Apply a function to visitable potentially asynchronously. This function is assumed to replace the value and trigger and events or replicated changes.
    
    Specified by:
    
    asyncUpdateKey in interface KeyedVisitable<T,M>
    
    Parameters:
    
    key - to visit within this collection.
    
    updateFunction - to update the state of the visibility.
  - syncUpdateKey
```
@Nullable
public <R> R syncUpdateKey(T key,
                                     @NotNull
                                     @NotNull net.openhft.chronicle.core.util.SerializableFunction<M,M> updateFunction,
                                     @NotNull
                                     @NotNull net.openhft.chronicle.core.util.SerializableFunction<M,R> returnFunction)
```
    Description copied from interface: KeyedVisitable
    
    Apply a function to update the state of a visible, and apply a function to return a result object synchronously.
    
    Specified by:
    
    syncUpdateKey in interface KeyedVisitable<T,M>
    
    Type Parameters:
    
    R - data type to return.
    
    Parameters:
    
    key - to update within this collection.
    
    updateFunction - update to apply to the value.
    
    returnFunction - derive an object to return
    
    Returns:
    
    the result of the code called.
  - applyToKey
```
@Nullable
public <T1,R> R applyToKey(T key,
                                     @NotNull
                                     @NotNull net.openhft.chronicle.core.util.SerializableBiFunction<M,T1,R> function,
                                     T1 argument)
```
    Description copied from interface: KeyedVisitable
    
    Apply a function which takes an argument. This argument may contain a combination of data. This function is assumed to not change the value in any significant way.
    
    Specified by:
    
    applyToKey in interface KeyedVisitable<T,M>
    
    Type Parameters:
    
    T1 - type of the argument
    
    R - type of the return value.
    
    Parameters:
    
    key - to visit within this collection.
    
    function - to apply
    
    argument - for the functions use.
    
    Returns:
    
    data derived.
  - asyncUpdateKey
```
public <T1> void asyncUpdateKey(T key,
                                @NotNull
                                @NotNull net.openhft.chronicle.core.util.SerializableBiFunction<M,T1,M> updateFunction,
                                T1 argument)
```
    Description copied from interface: KeyedVisitable
    
    Apply a function to visitable potentially asynchronously. This argument may contain a combination of data. This function is assumed to replace the value and trigger and events or replicated changes.
    
    Specified by:
    
    asyncUpdateKey in interface KeyedVisitable<T,M>
    
    Type Parameters:
    
    T1 - type of the argument
    
    Parameters:
    
    key - to update within this collection
    
    updateFunction - to update the state of the visitable.
    
    argument - for the functions use.
  - syncUpdateKey
```
@Nullable
public <T1,A,R> R syncUpdateKey(T key,
                                          @NotNull
                                          @NotNull net.openhft.chronicle.core.util.SerializableBiFunction<M,T1,M> updateFunction,
                                          @Nullable
                                          T1 updateArgument,
                                          @NotNull
                                          @NotNull net.openhft.chronicle.core.util.SerializableBiFunction<M,A,R> returnFunction,
                                          @Nullable
                                          A returnArgument)
```
    Description copied from interface: KeyedVisitable
    
    Apply a function to update the state of a visible, and apply a function to return a result object synchronously. This argument may contain a combination of data. Optionally the arguments could be null.
    
    Specified by:
    
    syncUpdateKey in interface KeyedVisitable<T,M>
    
    Type Parameters:
    
    T1 - update argument type.
    
    A - return argument type.
    
    R - data type to return.
    
    Parameters:
    
    key - to update within this collection
    
    updateFunction - update to apply to the value.
    
    updateArgument - for the update function to use.
    
    returnFunction - derive an object to return
    
    returnArgument - for the return value function to use
    
    Returns:
    
    the result of the code called.
  - compose
```
@NotNull
public <V> @NotNull Function<V,M> compose(@NotNull
                                                   @NotNull Function<? super V,? extends T> before)
```
    Specified by:
    
    compose in interface Function<T,M>
  - andThen
```
@NotNull
public <V> @NotNull Function<T,V> andThen(@NotNull
                                                   @NotNull Function<? super M,? extends V> after)
```
    Specified by:
    
    andThen in interface Function<T,M>
  - notifyClosing
```
public void notifyClosing()
```
  - isClosed
```
public boolean isClosed()
```
    Specified by:
    
    isClosed in interface net.openhft.chronicle.core.io.QueryCloseable

Class AuthorisedChronicleQueueView<T,M>

Nested Class Summary

Nested classes/interfaces inherited from interface software.chronicle.datagrid.queue.QueueView

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

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Methods inherited from interface software.chronicle.datagrid.pubsub.TopicPublisher

Methods inherited from interface net.openhft.chronicle.core.io.Closeable

Methods inherited from interface net.openhft.chronicle.core.io.QueryCloseable

Methods inherited from interface java.util.function.Function

Constructor Detail

AuthorisedChronicleQueueView

Method Detail

keySet

throwExceptionIfClosed

values

entrySet

getUsing

registerTopicSubscriber

unregisterTopicSubscriber

registerKeySubscriber

registerKeySubscriber

registerSubscriber

unregisterSubscriber

referenceFor

keyType

valueType

longSize

getAndPut

getAndRemove

unregisterTopicSubscriber

publisher

registerSubscriber

excerpt

next

next

set

publish

publishAndIndex

isEmpty

containsKey

containsValue

put

remove

putAll

clear

close

registerSubscriber

createSubAsset

putIfAbsent

remove

replace

replace

asset

underlying

keyedView

apply

size

getOrDefault

forEach

replaceAll

computeIfAbsent

computeIfPresent

compute

merge

equals

hashCode

applyTo

asyncUpdate

syncUpdate

applyTo

asyncUpdate

syncUpdate

get

applyToKey

asyncUpdateKey

syncUpdateKey

applyToKey

asyncUpdateKey