Package | Description |
---|---|
org.apache.river.api.security |
This package contains a scalable cache based security manager that parallelises
domain security checks.
|
org.apache.river.concurrent |
Custard-apple is a utility that enables weak, soft, strong
or time references to be used in any collection implementing standard
Java Framework Interfaces
Expected behaviour of reference types may vary between platforms
and should not be depended upon other than; weak references will
be collected when no further strong references remain and soft
references may be collected at any time the JVM's available memory
is under pressure and the referent is softly reachable.
|
Modifier and Type | Field and Description |
---|---|
private Comparator<Referrer<Permission>> |
CombinerSecurityManager.permCompare |
Modifier and Type | Interface and Description |
---|---|
(package private) interface |
UntouchableReferrer<T> |
Modifier and Type | Class and Description |
---|---|
(package private) class |
AbstractReferrerDecorator<T>
This class exists purely for allowing a client with their own Collection
implementation or Collection wrapper to perform custom serialisation of the
References by replacing the standard Referrer's with their own implementation.
|
(package private) class |
ComparableReferrerDecorator<T> |
(package private) class |
ReferenceSerializedForm<T>
A temporary but functional replacement for ReferenceKey's.
|
(package private) class |
ReferrerDecorator<T>
I've thought about refactoring so the equals and comparator behaviour is
implemented by the wrapper classes and only accepting References in
constructors as this would allow the use of standard java Reference classes
without extension, reducing the number of classes created,
however that would create serial form lock in.
|
(package private) class |
SoftEqualityReference<T>
Implemented as per Ref.SOFT
|
(package private) class |
SoftIdentityReference<T>
Implementation as per Ref.SOFT_IDENTITY
|
(package private) class |
StrongReference<T>
Implemented as per Ref.STRONG
|
(package private) class |
TempComparableReferrer<T> |
(package private) class |
TempEqualReferrer<T> |
(package private) class |
TempIdentityReferrer<T> |
(package private) class |
TimedComparableReferrerDecorator<T> |
(package private) class |
TimedReferrer<T> |
(package private) class |
TimedReferrerDecorator<T> |
(package private) class |
WeakEqualityReference<T>
Implemented as per Ref.WEAK
|
(package private) class |
WeakIdentityReference<T>
Implemented as per Ref.WEAK_IDENTITY
|
Modifier and Type | Field and Description |
---|---|
private Referrer<T> |
ReferrerDecorator.reference |
Modifier and Type | Field and Description |
---|---|
private Collection<Referrer<T>> |
ReferenceProcessor.col |
private Collection<Referrer<T>> |
ReferenceCollection.col |
private Collection<Referrer<T>> |
ReferenceCollectionSerialData.collection |
private Deque<Referrer<T>> |
ReferenceDeque.deque |
private java.util.concurrent.BlockingDeque<Referrer<T>> |
ReferenceBlockingDeque.deque |
private Map.Entry<Referrer<K>,Referrer<V>> |
ReferenceEntryFacade.entry |
private Map.Entry<Referrer<K>,Referrer<V>> |
ReferenceEntryFacade.entry |
(package private) ListIterator<Referrer<T>> |
ReferenceList.ReferenceListIterator.iterator |
private Iterator<Referrer<T>> |
ReferenceIterator.iterator |
private ReferenceQueuingFactory<K,Referrer<K>> |
ReferenceMap.krqf |
private ReferenceQueuingFactory<K,Referrer<K>> |
EntryFacadeConverter.krqf |
private List<Referrer<T>> |
ReferenceList.list |
private SortedMap<Referrer<K>,Referrer<V>> |
ReferenceSortedMap.map |
private SortedMap<Referrer<K>,Referrer<V>> |
ReferenceSortedMap.map |
private NavigableMap<Referrer<K>,Referrer<V>> |
ReferenceNavigableMap.map |
private NavigableMap<Referrer<K>,Referrer<V>> |
ReferenceNavigableMap.map |
private Map<Referrer<K>,Referrer<V>> |
ReferenceMap.map |
private Map<Referrer<K>,Referrer<V>> |
ReferenceMap.map |
private java.util.concurrent.ConcurrentNavigableMap<Referrer<K>,Referrer<V>> |
ReferenceConcurrentNavigableMap.map |
private java.util.concurrent.ConcurrentNavigableMap<Referrer<K>,Referrer<V>> |
ReferenceConcurrentNavigableMap.map |
private java.util.concurrent.ConcurrentMap<Referrer<K>,Referrer<V>> |
ReferenceConcurrentMap.map |
private java.util.concurrent.ConcurrentMap<Referrer<K>,Referrer<V>> |
ReferenceConcurrentMap.map |
private Queue<Referrer<T>> |
ReferencedQueue.queue |
private java.util.concurrent.BlockingQueue<Referrer<T>> |
ReferenceBlockingQueue.queue |
(package private) ReferenceQueuingFactory<T,Referrer<T>> |
ReferenceList.ReferenceListIterator.rqf |
private ReferenceQueuingFactory<V,Referrer<V>> |
ReferenceEntryFacade.rqf |
private ReferenceQueuingFactory<T,Referrer<T>> |
ReferenceCollection.rqf |
private ReferenceQueuingFactory<T,Referrer<T>> |
CollectionDecorator.rqf |
private ReferenceQueuingFactory<T,Referrer<T>> |
CollectionDecorator.Iter.rqf |
private SortedSet<Referrer<T>> |
ReferenceSortedSet.set |
private NavigableSet<Referrer<T>> |
ReferenceNavigableSet.set |
private ReferenceQueuingFactory<V,Referrer<V>> |
ReferenceMap.vrqf |
private ReferenceQueuingFactory<V,Referrer<V>> |
EntryFacadeConverter.vrqf |
Modifier and Type | Method and Description |
---|---|
(package private) static <T> Referrer<T> |
ReferenceSerializationFactory.create(T t) |
(package private) static <T> Referrer<T> |
ReferenceFactory.create(T t,
RefQueue<? super T> queue,
Ref type) |
Referrer<T> |
ReferrerDecorator.getReference() |
(package private) abstract Referrer<T> |
AbstractReferrerDecorator.getReference() |
Referrer<T> |
CollectionDecorator.Iter.next() |
Referrer<T> |
ReferenceProcessor.referenced(T w,
boolean enque,
boolean temporary) |
(package private) static <T> Referrer<T> |
ReferenceFactory.singleUseForLookup(T t,
Ref type)
This doesn't create a genuine reference, only a simple wrapper object
that will be used once then discarded.
|
(package private) Referrer<K> |
ReferenceMap.wrapKey(K key,
boolean enque,
boolean temporary) |
(package private) Referrer<T> |
ReferenceCollection.wrapObj(T t,
boolean enqueue,
boolean temporary) |
private Referrer<V> |
ReferenceEntryFacade.wrapVal(V val,
boolean enque) |
(package private) Referrer<V> |
ReferenceMap.wrapVal(V val,
boolean enque,
boolean temporary) |
Modifier and Type | Method and Description |
---|---|
static <T> Comparator<Referrer<T>> |
RC.comparator(Comparator<? super T> comparator)
When using a Comparator in SortedSet's and SortedMap's, the Comparator
must be encapsulated using this method, to order the Set or Map
by referents and not References.
|
Collection<Referrer<T>> |
ReferenceCollectionSerialData.getCollection() |
(package private) abstract Collection<Referrer<T>> |
ReadResolveFixCollectionCircularReferences.getCollection() |
(package private) ReferenceQueuingFactory<K,Referrer<K>> |
ReferenceMap.getKeyRQF() |
(package private) abstract Map<Referrer<K>,Referrer<V>> |
ReadResolveFixForMapCircularReferences.getRefMap() |
(package private) abstract Map<Referrer<K>,Referrer<V>> |
ReadResolveFixForMapCircularReferences.getRefMap() |
(package private) ReferenceQueuingFactory<T,Referrer<T>> |
ReferenceCollection.getRQF() |
(package private) ReferenceQueuingFactory<V,Referrer<V>> |
ReferenceMap.getValRQF() |
Iterator<Referrer<T>> |
CollectionDecorator.iterator() |
Map.Entry<Referrer<K>,Referrer<V>> |
EntryFacadeConverter.referenced(Map.Entry<K,V> w,
boolean enque,
boolean temporary) |
Map.Entry<Referrer<K>,Referrer<V>> |
EntryFacadeConverter.referenced(Map.Entry<K,V> w,
boolean enque,
boolean temporary) |
Modifier and Type | Method and Description |
---|---|
boolean |
CollectionDecorator.add(Referrer<T> t) |
int |
AbstractReferenceComparator.compare(Referrer<T> o1,
Referrer<T> o2)
This is implemented such that if either Referrer contains a null
referent, the comparison is only made using Referrer's, this may
have a different natural order, than the comparator provided, however
equals will always return 0, this is important to correctly remove
a Referrer once its referent has been collected.
|
int |
AbstractReferenceComparator.compare(Referrer<T> o1,
Referrer<T> o2)
This is implemented such that if either Referrer contains a null
referent, the comparison is only made using Referrer's, this may
have a different natural order, than the comparator provided, however
equals will always return 0, this is important to correctly remove
a Referrer once its referent has been collected.
|
int |
TimedComparableReferrerDecorator.compareTo(Referrer<T> o) |
int |
TempComparableReferrer.compareTo(Referrer<T> o) |
int |
ComparableReferrerDecorator.compareTo(Referrer<T> o) |
T |
ReferenceProcessor.pseudoReferent(Referrer<T> u) |
void |
ReferrerDecorator.refresh(Referrer<T> r) |
(package private) abstract void |
AbstractReferrerDecorator.refresh(Referrer<T> r)
This method is called after de-serialisation, to update the Referrer,
the Ref type will be governed by the ReferenceCollection, the queue will
have also been defined.
|
Modifier and Type | Method and Description |
---|---|
static <T> java.util.concurrent.BlockingDeque<T> |
RC.blockingDeque(java.util.concurrent.BlockingDeque<Referrer<T>> internal,
Ref type,
long gcCycle)
Decorate a BlockingDeque for holding references so it appears as a BlockingDeque
containing referents.
|
static <T> java.util.concurrent.BlockingQueue<T> |
RC.blockingQueue(java.util.concurrent.BlockingQueue<Referrer<T>> internal,
Ref type,
long gcCycle)
Decorate a BlockingQueue for holding references so it appears as a BlockingQueue
containing referents.
|
static <T> Collection<T> |
RC.collection(Collection<Referrer<T>> internal,
Ref type,
long gcCycle)
Decorate a Collection for holding references so it appears as a Collection
containing referents.
|
static <K,V> java.util.concurrent.ConcurrentMap<K,V> |
RC.concurrentMap(java.util.concurrent.ConcurrentMap<Referrer<K>,Referrer<V>> internal,
Ref key,
Ref value,
long gcKeyCycle,
long gcValCycle)
Decorate a ConcurrentMap for holding references so it appears as a ConcurrentMap
containing referents.
|
static <K,V> java.util.concurrent.ConcurrentMap<K,V> |
RC.concurrentMap(java.util.concurrent.ConcurrentMap<Referrer<K>,Referrer<V>> internal,
Ref key,
Ref value,
long gcKeyCycle,
long gcValCycle)
Decorate a ConcurrentMap for holding references so it appears as a ConcurrentMap
containing referents.
|
static <K,V> java.util.concurrent.ConcurrentNavigableMap<K,V> |
RC.concurrentNavigableMap(java.util.concurrent.ConcurrentNavigableMap<Referrer<K>,Referrer<V>> internal,
Ref key,
Ref value,
long gcKeyCycle,
long gcValCycle)
Decorate a ConcurrentNavigableMap for holding references so it appears as a
ConcurrentNavigableMap containing referents.
|
static <K,V> java.util.concurrent.ConcurrentNavigableMap<K,V> |
RC.concurrentNavigableMap(java.util.concurrent.ConcurrentNavigableMap<Referrer<K>,Referrer<V>> internal,
Ref key,
Ref value,
long gcKeyCycle,
long gcValCycle)
Decorate a ConcurrentNavigableMap for holding references so it appears as a
ConcurrentNavigableMap containing referents.
|
(package private) static <T> SerializationOfReferenceCollection<T> |
SerializationOfReferenceCollection.create(Class clazz,
Collection<Referrer<T>> refCol,
Ref type) |
(package private) static <K,V> SerializationOfReferenceMap<K,V> |
SerializationOfReferenceMap.create(Class clazz,
Map<Referrer<K>,Referrer<V>> refmap,
Ref type) |
(package private) static <K,V> SerializationOfReferenceMap<K,V> |
SerializationOfReferenceMap.create(Class clazz,
Map<Referrer<K>,Referrer<V>> refmap,
Ref type) |
static <T> Deque<T> |
RC.deque(Deque<Referrer<T>> internal,
Ref type,
long gcCycle)
Decorate a Deque for holding references so it appears as a Deque
containing referents.
|
static <T> List<T> |
RC.list(List<Referrer<T>> internal,
Ref type,
long gcCycle)
Decorate a List for holding references so it appears as a List
containing referents.
|
static <K,V> Map<K,V> |
RC.map(Map<Referrer<K>,Referrer<V>> internal,
Ref key,
Ref value,
long gcKeyCycle,
long gcValCycle)
Decorate a Map for holding references so it appears as a Map
containing referents.
|
static <K,V> Map<K,V> |
RC.map(Map<Referrer<K>,Referrer<V>> internal,
Ref key,
Ref value,
long gcKeyCycle,
long gcValCycle)
Decorate a Map for holding references so it appears as a Map
containing referents.
|
static <K,V> NavigableMap<K,V> |
RC.navigableMap(NavigableMap<Referrer<K>,Referrer<V>> internal,
Ref key,
Ref value,
long gcKeyCycle,
long gcValCycle)
Decorate a NavigableMap for holding Referrers so it appears as a NavigableMap
containing referents.
|
static <K,V> NavigableMap<K,V> |
RC.navigableMap(NavigableMap<Referrer<K>,Referrer<V>> internal,
Ref key,
Ref value,
long gcKeyCycle,
long gcValCycle)
Decorate a NavigableMap for holding Referrers so it appears as a NavigableMap
containing referents.
|
static <T> NavigableSet<T> |
RC.navigableSet(NavigableSet<Referrer<T>> internal,
Ref type,
long gcCycle)
Decorate a NavigableSet for holding references so it appears as a NavigableSet
containing referents.
|
Map.Entry<K,V> |
EntryFacadeConverter.pseudoReferent(Map.Entry<Referrer<K>,Referrer<V>> u) |
Map.Entry<K,V> |
EntryFacadeConverter.pseudoReferent(Map.Entry<Referrer<K>,Referrer<V>> u) |
static <T> Queue<T> |
RC.queue(Queue<Referrer<T>> internal,
Ref type,
long gcCycle)
Decorate a Queue for holding references so it appears as a Queue
containing referents.
|
(package private) void |
AbstractReferrerDecorator.refresh(ReferenceQueuingFactory<T,Referrer<T>> rqf) |
static <T> Set<T> |
RC.set(Set<Referrer<T>> internal,
Ref type,
long gcCycle)
Decorate a Set for holding references so it appears as a Set
containing referents.
|
static <K,V> SortedMap<K,V> |
RC.sortedMap(SortedMap<Referrer<K>,Referrer<V>> internal,
Ref key,
Ref value,
long gcKeyCycle,
long gcValCycle)
Decorate a SortedMap for holding references so it appears as a SortedMap
containing referents.
|
static <K,V> SortedMap<K,V> |
RC.sortedMap(SortedMap<Referrer<K>,Referrer<V>> internal,
Ref key,
Ref value,
long gcKeyCycle,
long gcValCycle)
Decorate a SortedMap for holding references so it appears as a SortedMap
containing referents.
|
static <T> SortedSet<T> |
RC.sortedSet(SortedSet<Referrer<T>> internal,
Ref type,
long gcCycle)
Decorate a SortedSet for holding references so it appears as a SortedSet
containing referents.
|
Constructor and Description |
---|
ComparableReferrerDecorator(Referrer<T> ref) |
ReferrerDecorator(Referrer<T> ref) |
TimedComparableReferrerDecorator(Referrer<T> r) |
TimedReferrerDecorator(Referrer<T> r) |
Copyright 2007-2013, multiple authors.
Licensed under the Apache License, Version 2.0, see the NOTICE file for attributions.