|
||||||||||
| PREV NEXT | FRAMES NO FRAMES | |||||||||
Accessor allows to redirect read and write access to an underlying element.Accessor instanceElementHolder to wrap a given element
AccessorReadable allows to redirect read access to an underlying elementAccessorWritable allows to redirect write access to an underlying element.Map which acts as a Cache
MethodInterceptor for a given MethodInvocationHandler
CollectionToCollectionAdapter instance
ListToListAdapter instance
SetToSetAdapter for the given Set
ListToSetAdapter for the given List
Iterable instance which uses an Iterator adapter based on the resolved
Iterable.iterator() instance.
Iterator which uses the given ElementConverter to convert the
result of the Iterator.next() method.
IteratorUtils.adapter(Iterator, ElementConverter)
IteratorUtils.adapter(Iterator, ElementConverter)
Iterator adapter on a given ElementStream
MapToMapAdapter for the given source Map
SortedMapToSortedMapAdapter for the given source SortedMap
BeanPropertyAccessor to the BeanPropertyAccessors container
String and the corresponding replacement to the StringReplacementBuilder
List instance or a new List instance if the given one is null.
ListUtils.add(List, Object) allowing to specify an index position
List instance or a new List instance if the given one is null.
ListUtils.add(List, Object...) allowing to specify an index position
SortedList.add(int, Object) ignores the given index position and acts similar to the SortedList.add(Object) method
Set, or a new instance if the given Set is null.
BeanPropertyAccessor instances to the BeanPropertyAccessors container
BeanPropertyAccessor instances to the BeanPropertyAccessors container
StringReplacementBuilder.add(String, String) for a given Map
Iterable to the given List instance.
ListUtils.add(List, Object...)
ListUtils.add(List, int, Object...)
Iterable to the given Set.
PreservationAndIgnorationDeclarer.addIgnoredType(Class)
PreservationAndIgnorationDeclarer.addPreservedType(Class)
PreparedBeanCopier.Configuration.addTypeToTypeMapping(Class, Class) but for both directions
Tuple to the EventListenerAdapter.ClientResultContainer.
ElementConverter pipe from one type to another type.
EventListener to the handler.
EventListener to the handler.
Tuple to the EventListenerAdapter.SourceEventDataContainer.
Iterator instance which contains all elements from the given Iterator and the additional given
elements.
List instance which contains all elements of the given List and additionally all further given
elements.
List instance which contains all elements of the given List and additionally the further given
element.
TreeNode to the current tree
TypeToTypeMappingDeclarer.addTypeAndPropertyNameMapping(Class, String, Class, String) but allows to further specify a path
Class type to another Class type
Codec.alphaNumeric() instead
EncoderAndDecoderAlphanumericTokens instance
AssertLogger.DirectAssert again to assert further expressions
Set of all Package instances known to the ClassLoader which are annotated with the given
package Annotation type
Set of all Package instances out of the given Set of Packages which are annotated
with at least one of the given package Annotation types
Map of all Packages annotated with at least one of the given package level Annotations
including the Annotation instances related to each Package.
Map of all Packages out of the given Packages Set annotated with at least one of
the given package level Annotations including the Annotation instances related to each Package.
Annotation instance for any Annotation declared on a Package with the given type of
Annotation
Annotation instance for the given type and annotation type.
Annotation instance for the given type and annotation type.
Class.getAnnotations() as List
AccessibleObject.getAnnotations() as List
AnnotatedElement.getAnnotations() as Map which has the Annotation type as key and its
related instance as value.
Future task return true for Future.isDone()
ForEach.Result are equal to the given value
Class.isAssignableFrom(Class) to their source type counterpart.
Objects are equal
Objects are equal
Objects are equal
FactoryTypeAware creating new instances of ArrayListArray instance as List.List.toArray(Object[]), returns null if a null reference is given.
Map containing an entry based on this KeyValue
Map containing an entry based on this Tuple.
Map containing an entry based on this Tuple.
Assert class offers assert methods which throw RuntimeExceptions if constraints are not fulfilled.RuntimeException that indicates a failed operation.AssertLogger provides methods of a Logger as well as methods of an Assert helper.AssertLogger using the LoggerFactory to create an Logger instance.
Exceptions or log messagesAssertLogger.DirectAssertSuccessFailureChoice.onSuccess() or AssertLogger.DirectAssertSuccessFailureChoice.onFailure().AssertLogger.DirectAssert with a previous set expressionAssertLogger.Loglevel of the AssertLogger.Assert based methods which throws appropriate Exceptions which it catches immediately and logs
it to the underlying Logger using the selected AssertLogger.Loglevel.AssertLogger.Loglevel and AssertLogger.LoglevelAssertAssertLogger.LoglevelAssertLogger.MessageFactory allows to produce messagesAssertLogger.LoglevelAssert instance
Set of assignable types which are implemented by the given type.
Set of assignable types which are implemented by the given type.
Set of assignable types which are implemented by the given type.
JAXBXMLHelper.UnmarshallingConfiguration based on the settings of this JAXBXMLHelper.MarshallingConfiguration instance
AutowiredContainer represents a high level container of objects which can be retrieved by the Class types
they are assignable to.AutowiredContainer which reduces the number of methods to be implemented.AutowiredContainerAutowiredContainerAutowiredPropertyContainer is a facade for autowired properties of a Java Bean class.Average calculates average values based on a given Collection of NumbersBeanCopier is a simple BeanReplicator which has the same source and target typeBeanMethodInformation object determined for the given Method.
BeanMethodInformation instances for all methods of a given Class.
BeanProperty allows to capture method calls for getter and setter methods on a Java Bean.BeanPropertyAccessorresolver for a Java BeanPropertyBeanProperty.Name resolver for a Java BeanPropertyBeanPropertyAccessor object determined for the given property name
BeanPropertyAccessor object determined for the given Field.
BeanPropertyAccessor object determined for the given Method.
Methods and Field of a special Java Bean type.BeanPropertyAccessors for a given Java Bean type
BeanPropertyAccessor instances.BeanPropertyAccessor instances for all Java Bean properties of the given Class
BeanReplicator allows to BeanReplicator.copy(Object, Object) or BeanReplicator.clone(Object) instances from one type to another
type.BeanReplicator.Declaration allows to declare several kinds of mappings a BeanReplicator should rely on.BeanReplicator.DeclarationSupport allows to add e.g. type to type or property name mappings, ElementConverter pipes,
preservations, ...BeanReplicator.PipeBuilder allows to construct a pipe from a given type to another over one or multiple
ElementConverter instances.BeanToNestedMapConverter marshalls a given JavaBean into a Map or unmarshalls a given Map into a
JavaBean.BeanToNestedMapConverter.BeanConversionFilter will decide which JavaBean should be converted into a Map and which should be put
directly into the Map as ObjectStringBeanUtils.BeanConverter.convert(Object) method which has to convert one bean type to another.TreeList.ElementList is traversed by the TreeList.ElementVisitor.visitElement(Object, int, List, int)
method.
List wrapper for Boolean types which provides some further methods to analyze the state of the values.Map.
PropertynameMapToTypeAdapter.Builder for the given Class type and PropertynameMapToTypeAdapter.Configuration.
SourcePropertyAccessorToTypeAdapter.Builder instance which allows to create multiple adapter instances much faster.
MapBuilder instance.
CharacterPathBuilder.CharacterPath from a given List of Strings.
String combinations of the current CharacterPathBuilder.CharacterPath and all descending CharacterPathBuilder.CharacterPath
instances related to the first one.
ByteArrayContainer creating an instance with no content.
ByteArrayContainer with a copied byte array content.
Cache is a container which allows to hold key value pairs.CachedElement provides an abstract cache mechanism around a given value.CachedElement.CachedValueCachedElement.ValueResolver which returns the object initially given to the constructor.CachedElement which allows declare a duration after passing that the cache becomes dirty and is not be
used anymore.Cache implementationsAverage of the stored values
DurationCapture.Interval.duration field based on the DurationCapture.Interval.startTime and DurationCapture.Interval.stopTime.
ListIteratorIndexBased.indexPositionPrevious , the ListIteratorIndexBased.indexPositionNext and the ListIteratorIndexBased.isIndexPositionValid
DurationCapture.IntervalStatistic
instance.
Callable.Map with String based keys which will provide a caseinsensitive CaseinsensitiveMapDecorator.get(Object) method.Array to a wrapper Class type and its elements to the element Class type using
ObjectUtils.castTo(Class, Object).
Array to a Map class.
Object to a given Class type.
Iterable which iterates through the Iterators of each given Iterable every time the own
Iterable.iterator() is called
Iterator wrapper which chains the given Iterator instances.
ChainedIterable allows to chain a given array of Iterable instances and merge them together into one single
Iterable.Iterator which is based on a chain of other Iterator instances.ListIterator which is based on a chain of other ListIterator instances.CharacterPathBuilder.CharacterPathCharacterPathBuilder.CharacterPath represents a path of characters.Iterable over CharSequence tokens which are based on another tokenized underlying CharSequence.CharacterSequenceTokenizerIterable instance for the given one which will return a circular Iterator which circulates
endlessly.
Iterable instance for the given one which will return a circular Iterator.
Iterator which will go through the underlying structure and starts from the beginning if the last element has
been passed.Class.forName(String) for the given type name but does not throw any Exception.
Maps to be treated as AutowiredContainer.BeanPropertyAccessors container
Element instances from this PropertyFileContent instance.
CachedElement.getValue() will resolve the value once again from the underlying
CachedElement.ValueResolver.
ExceptionHandlerManager.DispatchingExceptionHandlers
Futures which are Future.isDone()
EventManagerImpl instance.
EventManager instance.
BeanToNestedMapConverter.marshal(Object) and using BeanToNestedMapConverter.unmarshal(Map) again.
CloneableStructure.cloneStructure() method.CloneableStructureAndContent.cloneStructureWithContent() method.BeanUtils.copyPropertyValues(Object, Object) to the new created instance.
Map to store all properties and providing a proxy which accesses this underlying
Map.
Map to store all properties and providing a proxy which accesses this underlying
Map.
BeanToNestedMapConverter.clone(Object)
BeanToNestedMapConverter.clone(Object).
Object using JAXBXMLHelper.storeObjectAsXML(Object) and JAXBXMLHelper.loadObjectFromXML(CharSequence, Class)
JAXBXMLHelper.cloneObject(Object) allowing to specify a JAXBXMLHelper.MarshallingConfiguration
Object.clone().
Object.clone().
XMLEventReader which closes all iterators immediately
OutputStream which is used by a created proxy.
CodecCodec.Decoder offer the Codec.Decoder.decode(Object) method to decode encoded ObjectsCodec.Encoder provides an Codec.Encoder.encode(Object) method to encode give source ObjectsCollection interface.Collection consisting of multiple given Collection instances of the same type CollectionComposite.add(Object) method will add new elements to the Collection with the smallest size.CollectionDecorator is intended to decorate an existing Collection instance.Collection with its specific type to an underlying Collection with another specific type using
an ElementBidirectionalConverter instance to translate forth and back in types.CollectionToCollectionAdapterCollections into a single objectCollectionUtils.CollectionConverter which produces a String from a CollectionComment within a PropertyFileContentComparator used by this SortedList
Comparator will not be null
Comparator decorator using an internal WeakHashMap to cache the comparison values returned from the
given Comparator.
Comparator which uses List.indexOf(Object) to determine a comparing value for each element.
ComparatorCollectionComposite instance for the given Collections
CollectionComposite instance for the given Collections
SetComposite instance for the given Sets
SetComposite instance for the given Sets
MapComposite instance for the given Maps
MapComposite instance for the given Maps
ConcurrentWeakReferenceCache holds a given number of separated SynchronizedWeakReferenceCache instances,
called segments.ConcurrentWeakReferenceCache which uses as many segments as the
Runtime.availableProcessors() returns
Marshaller
JAXBContext
SAXParserFactory instance
Unmarshaller
JAXBContext
InputStream to a given OutputStream without closing the streams but flushing the
OutputStream.
Constructor for the given Class type and arguments
Constructor for the given Class type and parameter types
TreeList is Object.equals(Object) to the given Object
Iterable contains the given value.
ExceptionHandledResult contains any exception which could be assigned to the given Class
of Exception
Collection contains the given object.
BeanUtils.BeanConverter.
ForEach.Result to a single value using a CollectionUtils.CollectionConverter
Collection instance from one generic type into a single value using a CollectionUtils.CollectionConverter
Collection instance from one generic type into the other using a given ElementConverter.
Iterable instance from one generic type into the other using a given ElementConverter
Collection instance from one generic type into the other using a given ElementConverter.
Collection instance from one generic type into the other using a given
ElementConverterOneToMany.
Collection instance from one generic type into the other using a given ElementConverter.
Set of instances of another type using a given ElementConverter.
Collection instance from one generic type into the other using a given ElementConverter.
List element instance into an Map.Entry.
ElementConverter instances.
Iterable to a new Iterable type using the given ElementConverter
Map.Entry of a Map to a single element for a List
ArrayUtils.convertArray(Object[], Class, ElementConverter) but uses the given target array if the size fits
otherwise it will construct a new array with the same component type
Collection into another Collection with other element types using an
ElementConverter.
Collection into another Collection with other element types, whereby all elements which
convert to null will not be inserted into the target Collection.
Converter allows to declare a Class of an ElementConverter which should be used to translate a
return value or a single given parameter before storing it in the underlying structure.Collection instance from one generic type into the other using a given ElementConverter.
CharacterSequenceTokenizer which allows to use an ElementConverter to modify the output type of
the Iterator.next() method.ConvertingCharacterSequenceTokenizerDecorator which outputs a StringCollection instance from one generic type into the other using a given
ElementConverterOneToMany.
Map instance with converted keys and values using the given ElementConverters
MapUtils.convertMap(Map, ElementConverter, ElementConverter) using a single ElementConverter for an
Map.Entry
Map instance with converted keys using the given ElementConverter
Map instance with all values converted using the given ElementConverter
NodeMap into a normal Map with hierarchical keys.
NodeMap into a normal Map with hierarchical keys.
TreeNavigator.TreeNodeVisitor.TraversalConfiguration but uses all explicit given flags if they are not null.
File into the ByteArrayContainer.
InputStream into the ByteArrayContainer without closing the InputStream ByteArrayContainer is set to invalid.
URL.openStream() to retrieve data which will be available within the ByteArrayContainer ByteArrayContainer.isContentInvalid() will return true afterwards.
ByteArrayContainer.copyFrom(URL)
Readable using the "utf-8" encoding
Readable using the given encoding
String into the ByteArrayContainer.
CharSequence into the ByteArrayContainer using the "utf-8".
CharSequence into the ByteArrayContainer.
Serializable element and stores it
Iterable into the given Collection
Iterable into the given Collection
Iterator into the given Collection Iterator
Iterator into the given Collection.This traverses the Iterator
only as far as necessary.
BeanPropertyAccessor to another Java
Bean.
BeanPropertyAccessor to another instance
using the given BeanPropertyAccessor
Iterable which are equal to the given element.
Index instance which is appended to the current list of Index elements.
Index element before the given current Index.
URI based on the given location
Uri which is based on the given base address and a relative path
BeanReplicator.Declaration BeanReplicator.Declaration have to be made before any call to BeanReplicator.copy(Object, Object) or BeanReplicator.clone(Object)
Annotation if the given Class type declares the given Annotation class
Class.getDeclaredAnnotations() as List
AnnotatedElement.getDeclaredAnnotations() as Set
Field within a given Class.
Field within a given Class.
Class.getDeclaredFields() for a given Class.
Method within a given Class.
Class.getDeclaredMethods() for a given Class.
List of ReflectionUtils.MethodParameterMetaInformation instances for each parameter the given
Method has.
Map of all declared Methods of the given Class type and a List of declared
Annotations related to the Methods
Map with the declared Methods of the given type and the return type of the Methods
ObjectUtils.defaultIfNull(Object, Object, Object...)
Factory .
JAXBXMLHelper.MarshallingConfiguration if a null reference is given, otherwise the given instance.
JAXBXMLHelper.UnmarshallingConfiguration if a null reference is given, otherwise the given instance.
DefaultValue Annotation allows to declare a value which is used as default value, if a given or returned
value of a method is null.MapUtils.defaultValueMap(Map, FactoryParameterized)
Map which always returns a value prodcued by the given factory if the value would have be null
DefaultValues Annotation allows to declare a value which is used as default value, if a given or returned
value of a method is null.SetDelta instance for the given Sets
MapDelta for the given two Map instances
MethodCallCaptures from the given root stub as base.
ElementConverter instance within the ElementConverterRegistration.
CharacterPathBuilder.CharacterPath as a concatenated String
DurationCapture.Interval for the given key.
QName defined by the XmlRootElement of the given Class type
List of token path elements which represents the current hierarchy path.
BitSet which has its bits set to true at the same index where the related element from one array to the
other array is not Object.equals(Object)
DirectoryBasedObjectStore acts as List facade on a given directory structure.Object store based on a nested directory structure using JAXBObject store based on a nested directory structure using Java serialization.Object store based on a nested directory structure using XStreamEventManager to the EventListenerRegistration from another EventManager
instance.
DispatcherAbstract allows to implements dispatcher instancesXMLIteratorFactory instance with the configuration of this one but holding an additional xml tag scope
restriction.
XMLIteratorFactory instance with the configuration of this one but holding an additional xml tag touch
barrier restriction.
Iterator instances will use ThreadLocal states.
Iterables have to have threadsafe Iterable.iterator() instances, since even
the Iterators will be called from parallel running threads.
XMLIteratorFactory.XMLEventTransformer which does lower case the xml tag and attribute names
XMLIteratorFactory.XMLEventTransformer which does remove all Namespace declarations on any xml tag and attribute
XMLIteratorFactory.XMLEventTransformer which does upper case the xml tag and attribute names
Iterable to the given Collection
Iterable by the given maximum number of elements to the given Collection.
Iterator to the given Collection Iterator.remove() method for every element drained.
Iterator by the given maximum number of elements to the given Collection.
DualMap is the dual way counterpart of the Map interface.DurationCapture will measure time intervals.DurationCapture.Interval instances.Callable decorator which captures the duration of the Callable.call() methodRunnable decorator which captures the duration of the Runnable.run() methodElement within a PropertyFileContentList.
Iterable at the given index position.
List.
ElementConverter which additonally specify a ElementBidirectionalConverter.convertBackwards(Object) method, so that a two way conversion is
possibleElementBidirectionalConverter which additionally extends the Serializable interfaceElementBidirectionalConverter which makes use of Collections.unmodifiableSet(Set) within its
ElementBidirectionalConverterSetToUnmodifiableSet.convert(Set) method but not in its ElementBidirectionalConverterSetToUnmodifiableSet.convertBackwards(Set) methodElementBidirectionalConverter which encloses a given element into a WeakReferenceElementConverter.convert(Object) method to transform one element instance into another.String using the Codec.alphaNumeric() codecElementConverter for converting BeanPropertyAccessor instances to property namesElementConverter which abstracts a chain of other ElementConverter instancesElementConverter which converts a given Class type to an FactoryTypeAware instance which creates
instances of the given type using ReflectionUtils.newInstanceOf(Class, Object...)ElementConverter which converts a given Class type to an instance using FactoryTypeAwareReflectionBasedList element type to a Map.Entry typeElementConverterElementBidirectionalConverter implementation which casts the given object and returns it.ElementConverter implementation which returns the Class instances of a given Object by
calling Object.getClass()Collection instance into one or multiple elements of
other type.ElementConverter and ElementConverterTypeAware instances.ElementConverter which additionally implements the Serializable interfaceString using the Codec.alphaNumeric() codecElementConverter for converting Strings into Patterns using Pattern.compile(String)ElementConverter instances acting like an ElementBidirectionalConverter ElementConverter is null, the respective transformation direction will throw an
UnsupportedOperationExceptionElementConverter which allows to retrieve the source and target types using
ElementConverterTypeAware.getSourceAndTargetType().ElementConverterTypeAware implementation which allows to resolve the
ElementConverterTypeAware.getSourceAndTargetType() based on the generic types of the ElementConverter.ElementConverterTypeAware which additionally extends the Serializable intefaceElementFilter provides a ElementFilter.filter(Object) and a ElementFilter.getFilterMode() method.ElementFilter.FilterMode.EXCLUDING or ElementFilter.FilterMode.INCLUDINGExcludingElementFilterIndexPositionBased which filters all elements which do not have any of the given index numbersExcludingElementFilter which filters / removes all blank elements.ElementHolderUnmodifiable allows to ElementHolder.setElement(Object)ElementHolderUnmodifiable around an arbitrary element.Objects which can be resolved by a ElementStream.next() methodElementStream as Iterator.List at the given reverse index position which is counted beginning from the last
element.
Iterable which returns always a new empty Iterator
Iterator
ArrayList
LinkedHashSet instance
List to match the size of the list of declared methods of the underlying Class.
Map.Entry at the given index position of the given Map.
Set of all Map.Entrys within the Cache which only represents a
snapshot in moment
Collections are equal and have the same order
Property.getKey() and Property.getValueList() are equal.
EncoderAndDecoderEscaping instance
EventListener event implementation.EventManager instances with
EventManagerImpl#listenTo(EventListenerRegistration, EventListenerAdapter).EventListener which offers several overwritable methods to handle the event.EventListener instances.EventManager is the central control unit within a client class which want to fire events.EventManager to another EventManager or EventListenerRegistration.EventListener instances which implements the EventListener interface, too.EventListeners at a EventListenerRegistration.ExceptionHandledResult is the result of an operation which catches Exceptions and does not throw them.ExceptionsExceptionHandlerSerializable holding an internal state flag.ExceptionHandler which delegates to another instanceExceptionHandler which does call Throwable.printStackTrace()ExceptionHandler which does nothingExceptionHandler which logs as ERROR using a slf4j Logger instanceExceptionHandlerManager will manage instances of ExceptionHandlerManager.DispatchingExceptionHandlersExceptionHandler which dispatches to the ExceptionHandlerManager.exceptionHandlerSet.ExceptionHandler which dispatches to the ExceptionHandlerManager.exceptionHandlerSet rethrowing any
Exception as RuntimeExceptionExceptionHandlerExceptionHandler which does rethrow the given Exception as cause of a new RuntimeExceptionExceptionHandler which implements the Serializable interfaceElementFilter which returns ElementFilter.FilterMode.EXCLUDING for the
ExcludingElementFilter.getFilterMode() methodExcludingElementFilter which removes all given elements where the constructor element equals to.ExcludingElementFilter which filters / removes all null elementsOperation and uses the given CollectionUtils.CollectionConverter to produce a single result value
ForEach Operation
ForEach Operation
OperationVoid on all dispatch instances
OperationIntrinsic.execute() with the given parameter and handles any occurring Exception
Operation.execute(Object) with the given parameter and handles any occurring Exception
OperationUtils.executeWithLocks(OperationIntrinsic, Lock...)
Factory interface.Iterator instance which will iterate over all Iterator instances created by the given
Factory.
FactoryFactoryParameterized which extends Serializable as wellFactory which is SerializableFactory in combination with a given type as FactoryTypeAware instanceFactory which holds FactoryTypeAware.getInstanceType() information about the created instance type.FactoryTypeAware which uses ReflectionUtils.newInstanceOf(Class, Object...) to create new instances.Factory which provides a FactoryWithArguments.newInstance(Object...)Class.getFields() for a given Class.
List using a ElementFilter on the given Collection
List using a ElementFilter on the given Iterable
List using a ExcludingElementFilterIndexPositionBased
List instance which contains all elements from the given List which have a related bit within
the BitSet set to true
Iterable and returns a Set which only contains the elements which are not filtered out by
the given ElementFilter.
ElementFilter.filter(Object) method should return true if the given element matches the internal ElementFilter.FilterMode
List instance based on the given source Iterable.
Iterable where the Iterable.iterator() instance returns only those elements where the respective
bit within the filter BitSet is set to true
Iterator which returns a filtered subset of the given Iterator based on the given filter
BitSet
Map instance.
Map by its keys.
Map by values which are null.
Collection with elements of type String and returns a new
List instance.
List which does not contain the given element
Collection and returns a new List instance.
SortedList.
List.
Iterable
List
Map.Entry of a given Map or null if the Map reference is null or the Map is
empty
ForEach will iterate over a given Iterable instance and executes a given List of Operations.ForEach.Result of a ForEach Operation which is basically an unmodifiable List of all returned
instances from the Operations.TreeNavigator.
TreeNavigator.TreeNodePathAndCache
String array using String.format(String, Object...)
StringUtils.formatPerArrayElement(String, Object...) using String.format(Locale, String, Object...) instead.
Future implementation using a CountDownLatch which unlocks when the value is set.FutureTaskManager will manage the Futures created e.g. by a
ExecutorService.submit(java.util.concurrent.Callable) call and allows to wait on all managed Futures.FutureTaskManager.submitAndManage(Callable) and FutureTaskManager.submitAndManage(Runnable).
List using the given value Factory to create all the elements the given number of times.
BeanPropertyAccessor at the given index position
List instance.
Iterator instance or null, if no instance is active.
ListIterator instance or null, if no instance is active.
Set to became the second Set
BeanPropertyAccessor.getAnnotation(Class, PropertyAccessType) using the default BeanPropertyAccessor.PropertyAccessType
Annotation instance declared on the field or methods for the related property depending on the
BeanPropertyAccessor.PropertyAccessType.
List of the canonical method names captured by the last active stub.
List of the canonical method names captured by the given stub but with all hierarchical calls like
testInterface.doTestSubInterface().doCalculateSomething() which result in
testInterface
testInterface.doTestSubInterface
testInterface.doTestSubInterface.doCalculateSomething
merged into a single representation like:
testInterface.doTestSubInterface.doCalculateSomething
List of the canonical property names captured by the last active stub.
List of the canonical method names captured by the given stub but with all hierarchical calls like
testInterface.doTestSubInterface().doCalculateSomething() which result in
testInterface
testInterface.fieldObject
testInterface.fieldObject.fieldString
merged into a single representation like:
testInterface.fieldObject.fieldString
List of references to the children of the current TreeNode
List of children which are determined when the TreeNode is added to the
TreeNavigator.TreeNodePathAndCache
TreeNode List of the parental TreeNode
TreeNode List of the parental TreeNode
TreeNode
TreeNode
BeanPropertyAccessor.getDeclaringPropertyType(PropertyAccessType) but using all given BeanPropertyAccessor.PropertyAccessTypes.
BeanPropertyAccessor.getDeclaringPropertyType(PropertyAccessType) using the default BeanPropertyAccessor.PropertyAccessType
Class type for the property.
TimeUnit.
TimeUnit.
TimeUnit for all given interval keys.
DurationCapture instance which measures the time of method calls.
AccessorReadable does point to
Elements managed by this PropertyFileContent instance.
Elements managed by this PropertyFileContent instance sorted in ascending
order by their index position (which has the same order as the line numbers).
EventListenerRegistration to register EventListener to this instance.
Exception if one was thrown during the replay.
List of all catched Exceptions
Field
ElementFilter.FilterMode in which the filter acts.
Exception if any Exception is present
List of manage Futures
ThreadLocal specific instance which will be created at the first time of use with a given Thread.
Class type the Factory.newInstance() method produces
TimeUnit.
TimeUnit
TimeUnit for all given interval keys.
DurationCapture.Interval keys.
Map instance with all DurationCapture.Interval keys and the related DurationCapture.getDurationInMilliseconds(Object)
as value
Map instance with all DurationCapture.Interval keys and the related DurationCapture.getDuration(TimeUnit) as value
SetDelta of the Map.keySet()
MethodCallCapturer.MethodCallCaptureContext which has been reported to this MethodCallCapturer.
List to which all method invocations should be forwarded.
Map for the current Thread context
Method.
MethodCallCapturer.MethodCallCaptureContext instances.
MethodCallCapturer.MethodCallCaptureContext instances for a given stub instance.
MethodCallCapturer.MethodCallCaptureContext instances for the last active stub instance.
MethodCallCapturer.MethodCallCaptureContext instances for a given stub instance.
MethodCallCapturer
Method
Method.
Method
Tree
TreeNode
TokenMonoHierarchy.Navigator for the TokenMonoHierarchy
Index which follows the given Index
List of all non matching property names
Factory and puts the new value into the cache.
OutputStreamWriter using the given encoding
ByteArrayContainer.getOutputStreamWriter(String) using the ByteArrayContainer.DEFAULTENCODING
TreeNode of the current TreeNode is one exists, otherwise null
Index is comes before the given Index.
PrintStream using the "utf-8" encoding
PrintStream
PrintStream
Property instances.
PropertyMap view on the Property elements of this PropertyFileContent instance.
Map for all properties which can be assigned to the given Class.
BeanPropertyAccessor.getPropertyValue(Object, ExceptionHandler, PropertyAccessType...) with no ExceptionHandler
BeanPropertyAccessor.getPropertyValue(Object, PropertyAccessType, ExceptionHandler) using all the given
BeanPropertyAccessor.PropertyAccessTypes
QNames of the currents element location.
Reader with the default encoding "utf-8"
Reader using the given encoing
Set to become the second Set
List of the event results
Map
Set
Map with all retained keys between the first and second map which have not changed their value
Map with all retained keys between the first and second map which have changed their value
Future.cancel(boolean) method has been called at least once
ElementConverterTypeAware.SourceAndTargetType of the ElementConverter
MethodCallCapturer.MethodCallCaptureContext was created for one of its methods called.
MethodCallCapturer.MethodCallCaptureContext.
List with all token elements of the children.
List instance containing the current path of TreeNodes
TreeNode
List which underlies this class type facade.
Map
Map which underlies this class type facade.
Class type.
CachedElement.ValueResolver if it is null.
Map which matches a given regular expression.
Tuple.
Tuple.
Tuple.
Tuple.
Set for all values which can be assigned to the given Class.
EventManager when events are being fired.
Exception
Object.toString() method
Iterator instance set
Iterator instance set
Class type declares or inherits the given Annotation class from any supertype, but
not from interfaces
Field declares the given Annotation class
Class type declares or inherits the given Annotation class from any supertype, but
not from interfaces
Class type has any annotation of the given type on any of its methods
Class type has any annotation of the given types on any of its methods
Map
TreeNode.getChildrenList() is not empty
Class type has a Constructor for the given arguments
Class type has a Constructor for the given parameter types
Class type declares the given Annotation class
Method declares the given Annotation class
Class type has a default Constructor
DurationCapture.Interval instance for the DurationCapture.INTERVAL_DEFAULTKEY.
Exceptions have been catched
FutureTaskManager has an ExecutorService available
Field has a getter and a setter method.
Field has at least a getter or a setter method or both available.
Object.hashCode() for a given Iterable and its elements.
Factory for HashMap intancesFactoryTypeAware creating new instances of HashSetOperationBlockingToFastRepeatingExecutions.execute(Object) will be forced to wait for
OperationBlockingToFastRepeatingExecutions.forcedDurationAfterToFastInvocationInMilliseconds
ListIteratorDecoratorSwitchable.switchToNext() will find another active ListIterator
TreeNode has a next sibling
CharacterPathBuilder.CharacterPath has no children
Exceptions have been catched
TreeNode has a parent
ListIteratorDecoratorSwitchable.switchToPrevious() will find another active ListIterator
TreeNode has a previous sibling
Property is present.
Property with the given key exists.
Property with the given key exists.
Property is present.
ExceptionHandledResult.getResult() is not null
CachedElement.ValueResolver instance.
SortedList which starts at the beginning and ends by the given element which itself is
excluded from the head list.
List by given element instances.Set implementation using the IdentityArrayList as backing structure.LinkedHashMap but using the identity comparison "object == element" for resolution of keys and values.Index which corresponds strongly to line numbers.List of all index positions for the given element.
Object.equals(Object) to the given
Object
Collection.
Map instance which returns for Map.get(Object) always an AtomicInteger instance.
EnumMap filled with all available values of the given Enum type as keys and the result of the
Factory as value for each Enum key.
MapUtils.initializedMap(Map, Factory) using a new LinkedHashMap instance
MapUtils.initializedMap(Map, FactoryParameterized) using a new LinkedHashMap instance
MapDecorator which ensures that all Map.get(Object) invocations with a valid key type will return a
value.
MapDecorator which ensures that all Map.get(Object) invocations with a valid key type will return a
value.
MapUtils.initializedMap(Map, Factory) but for any SortedMap instance
MapUtils.initializedMap(Factory) using an ArrayListFactory
MapUtils.initializedMap(Factory) using an ArrayListFactory
MapUtils.initializedMap(Factory) using an LinkedHashSetFactory
MapUtils.initializedMap(Factory) using an LinkedHashSetFactory
MapUtils.initializeMap(Map, Iterable, Factory, boolean) but does not overwrite values of already existing keys.
Map for all keys from the key Iterable with values created by the value
Factory.newInstance() method.
OperationBattery before the constructor call ends.
Map with the matching keys and the respective value instances within a of Tuple2 wrapper, which has
always the value of the first map and the value of the second map.
InputStream which delegates all methods to the given InputStream instanceInputStream which only relies on the InputStreamDecoratorSimple.read() method of the given InputStream for
any of the available read operations like InputStream.read(byte[]) and InputStream.read(byte[], int, int).SortedList implementation using insertion sort algorithm based on a simple ArrayListSet of interfaces which are implemented by the given type.
List with only this elements which are in all of the given Collections
List with only this elements which are in all of the given Collections
Collections of the given container Collection
Set instances by iterating over the smaller given Set and testing on
the Set.contains(Object) method of the larger Set.
Collections of the given container Collection
Collections of the given container Collection
ElementBidirectionalConverter instance which inverts the direction of the given instance
DualMap instance but with inverted key and value
Map for the given one.
Map.Entry view of the current Map.Entry.
Map for the given one.
Array
Object is not null and an Array type.
Class.isArray() is true
Class is Class.isAssignableFrom(Class) for the given Class type.
Class is Class.isAssignableFrom(Class) from the given Object.
Object is not null and a Collection derived type
ByteArrayContainer has put the content into a malformed state.
BeanPropertyAccessors container has no BeanPropertyAccessor instances
Class type can be handled
Class type can be handled
DurationCapture.getInterimTimeInMilliseconds(Object...) is lower than the given duration limit for
the given TimeUnit and interval keys.
DurationCapture.getInterimTime(TimeUnit) is lower than the given duration limit.
DurationCapture.getInterimTime(TimeUnit) is lower than the given duration limit.
Object is not null and a Iterable derived type
Iterable interface
CharacterPathBuilder.CharacterPath represents a leaf node.
Object is not null and a List derived type
List
Object is not null and a Map derived type
Map interface
MethodCallCapturer.MethodCallCapturerAware interface.
Collections is not null and not empty.
Collections is not null and not empty.
Collections is not null and not empty.
Object is not null, otherwise an IllegalArgumentException is thrown
Objects are not null.
Object is not null.
Objects are not null.
Objects are not null.
Objects are not null.
Object is not null.
ObjectUtils.isPrimitiveType(Class) or ObjectUtils.isPrimitiveWrapperType(Class) returns true
Class.isPrimitive() is true for the given type
Class type is a wrapper type of a primitive.
BeanPropertyAccessor.PropertyAccessType is field and the class definition has a field or if BeanPropertyAccessor.PropertyAccessType
is property and the class declares a getter.
BeanPropertyAccessor.PropertyAccessType is field and the class definition has a field or if BeanPropertyAccessor.PropertyAccessType
is property and the class declares a getter and a setter.
CharacterPathBuilder.CharacterPath is the root node and returns null for the CharacterPathBuilder.CharacterPath.getCharacter()
Set interface
Object is not null and a SortedMap derived type
SortedMap interface
Object is not null and a SortedSet derived type
SortedSet interface
OperationBattery will ensure thread safetyness using a ReentrantLock on
Operation instances.
Range
BeanPropertyAccessor.PropertyAccessType is field and the class definition has a field or if BeanPropertyAccessor.PropertyAccessType
is property and the class declares a setter.
List from a given Iterable
Iterable instancesIterableUtils.IterableReplicator allows to replicate elements to a given CollectionListIterator over a set of elements
List from a given Iterator
IteratorDecorator decorates an existing Iterator instance.Iterator decorator, which holds a List of Iterator instances which it can address.Iterator which uses an ElementConverter to convert the output of the IteratorToIteratorAdapter.next() method of
the underlying Iterator to another type .Iterator with one specific type to another Iterator with another type using a given
ElementBidirectionalConverterIteratorXmlRootElement for any Collection.List wrapper which acts as an XmlRootElement for any List.JAXBMap is a artificial XmlRootElement for an arbitrary Map instance.Name which can be translated via jaxbSet wrapper which acts as an XmlRootElement for any Set.XMLIteratorFactory.JAXBTypeContentConverter implementation using StAXONUnmarshaller instanceJAXBXMLHelper.UnmarshallingConfiguration.Configurator is able to configure several internal instances like JAXBContext and Marshaller.JAXBXMLHelper.UnmarshallingConfiguration.Configurator is able to configure several internal instances like SAXParserFactory, JAXBContext,
Unmarshaller.MapJoiner instance
Map and the now given right Map
MapJoiner.From.joinInner(Map) but using a given Iterable and a related KeyExtractor
Set of all keys within the Cache which only represents a snapshot in moment
Tuple supporting KeyValue.hashCode(), KeyValue.equals(Object) and KeyValue.toString() using the values of
the given elements.KeyValue instance based on the values of an already existing instance
SortedList.
List.
Iterable
List.
Map.Entry of the given Map.
Collection.
Queue which can be configured to ignore further adding of elements if the size limit is reached, or to
dump the oldest entry.Iterator which will limit the elements which can be retrieved to
the given number
DualMap implementation which makes use of two LinkedHashMap instances to get an index on keys and values.FactoryTypeAware creating new instances of LinkedHashSetListAbstract including the ListAbstract.ListAbstractSublist.fromIndex and excluding the ListAbstract.ListAbstractSublist.toIndexListDecorator is intended to decorate an existing List instance.List instances.ListDispatcher.ListDispatchControl allows to control to which List the method invocations to the ListDispatcher
will be forwarded to.EventManager to the EventListenerRegistration from another EventManager
instance.
ListIterator instance.ListIterator instance.ListIterator decorator, which holds a List of ListIterator instances which it can
address.ListIterator implementation which translates the navigation and actions to index position based operationsList implementation to act as a ListIteratorIndexBased.ListIteratorIndexBasedSourceList with a specific type to be used as a List with another specific type using a
ElementBidirectionalConverterListToListIteratorAdapter.next() the element at the given start index
position of the list.
Set operating on a given List.MethodInterceptor implementation special for this ListToTypeAdapterList instances.PropertyFile from disc.
PropertyFile from the given String
ByteArrayContainer.copyFrom(File) instead
JAXBXMLHelper.loadObjectFromNode(Node, Class, ExceptionHandler) but ignoring Exceptions
Node.
InputStream.
InputStream.
JAXBXMLHelper.loadObjectFromXML(InputStream, Class) allowing to declare a JAXBXMLHelper.UnmarshallingConfiguration
Object from a CharSequence which contains valid xml text content.
Object from a CharSequence which contains valid xml text content.
JAXBXMLHelper.loadObjectFromXML(CharSequence, Class) allowing to specify an JAXBXMLHelper.UnmarshallingConfiguration
Collection which uses the given Lock to synchronize all of its methods
List using the given Lock to synchronize all of its methods
ListIterator which uses a Lock to synchronize all its methods.
Set using the given Lock to synchronize all of its methods
Map using the given Lock to synchronize all of its methods
Collection which uses a new ReentrantLock instance to synchronize all of its
methods
List using a new ReentrantLock instance to synchronize all of its methods
ListIterator which uses a ReentrantLock to synchronize all its methods.
Set using a new ReentrantLock instance to synchronize all of its methods
Map using a new ReentrantLock instance to synchronize all of its methods
Iterator which uses a ReentrantLock to synchronize all its methods.
Iterator which uses a Lock to synchronize all its methods.
CollectionDecorator which uses a Lock instance to synchronize all methods of an underlying CollectionReentrantLock instance as Lock
IteratorDecorator which uses a Lock instance to synchronize its methodsReentrantLock instance as Lock
ListDecorator which uses a given Lock instance to synchronize all of its methods.ReentrantLock instance as Lock
ListIteratorDecorator which uses a Lock to synchronize all of its methods.ReentrantLock instance as Lock
MapDecorator which uses a Lock instance to synchronize every method invocation.ReentrantLock instance is created
SetDecorator which uses a Lock to synchronize all of its methods.ReentrantLock instance as Lock
Exception using the given AssertLogger.DirectAssertHandlerMessageChoice.LogLevel
Future
Future instances
MapBuilderOld using a MapBuilderOld.MapFactory to create a Map instance at MapBuilderOld.MapBuilderWithMap.build() time
MapBuilderOld instance creator method which creates a MapBuilderOld with a Map instance of
the given Class by using reflection.
Map reducing the Map interface to the very needed operations.Map implementation does implement all methods which rely only on other methods within the Map
interface.Set based on a given Map implementationMap instances filled with keys and values.MapBuilder.ClosedMapComposer allows to create specific Map instances containing the key value pairs defined with the
MapBuilder.MapComposerMapBuilder.MapComposer allows to compose a Map by adding key value pairs.Map instanceMapBuilder.MapComposerMapUtils.builder() or MapBuilder insteadMapBuilderOld which has a declared Map type and now allows to modify and build a MapMap instanceMap implementation which is based on a given List of further Map instances.Map implementationMap implementationMapDelta will calculate the SetDelta of the Map.keySet() and the delta between the values of the
retained keyset.MapJoiner allows to join two or multiple Map instances by their keys.MapJoiner.JoinedValue special for a Map join result containing both values for a shared keyMapJoiner.Predicate which uses a given Set of keys to return true for any result value which has a key contained within
that given Set.Map to CacheMapToCacheAdapter.entrySet(), MapToCacheAdapter.values() and MapToCacheAdapter.keySet() will return an unmodifiable instanceMapToMapAdapter is a decorator and adapter which allows to access a given Map using other types for the key
as well as for the value.MapToMapAdapter which only converts the keys of a MapMapToMapAdapter which only converts the values of a MapMap operations.MapUtils.MapElementMergeOperation defines a MapUtils.MapElementMergeOperation.merge(Object, Object, Map) operation to merge Map elements into
a merged Map instance.Map.Entry of a Map to a single List elementMap adapter which allows to define a mapping for the keys of the underlying MapMap
CharacterPathBuilder.CharacterPath which matches the last character of the given relative path to the current
CharacterPathBuilder.CharacterPath.
Matcher.matches() call.List with the maximum given size.
Iterable String elements
BeanPropertyAccessor instances into one if the underlying Class and property are equal.
Array containing all elements of each of the given Arrays.
Iterator instance.
Collection instances into one single Collection instance which keeps the
order of the elements.
Collection instances into one single List instance which keeps the order of
the elements.
Collection instances into one single List instance which keeps the order of
the elements.
Collection instances into one single Set instance.
Collection instances into one single Set instance .
Map instances into a single LinkedHashMap using the given MapUtils.MapElementMergeOperation.
Map instances into a single LinkedHashMap using the given MapUtils.MapElementMergeOperation.
Map instances into a single LinkedHashMap.
Map instances into a single LinkedHashMap.
MapUtils.mergeAllValuesIntoList(Collection)
Map instances whereby multiple values for the same key are merged into a List
MapUtils.mergeAllValuesIntoSet(Collection)
Map instances whereby multiple values for the same key are merged into a Set
MethodCallCapturer.MethodCallCaptureContexts into the most nested MethodCallCapturer.MethodCallCaptureContext for each group
of MethodCallCapturer.MethodCallCaptureContexts
Throwable to the Logger using the selected AssertLogger.Loglevel.
Logger using the selected AssertLogger.Loglevel AssertLogger.MessageFactory.message() method is only invoked if the respective AssertLogger.Loglevel is set to true within the
logging configuration.
Throwable to the Logger using the selected AssertLogger.Loglevel
Throwable to the Logger using the selected AssertLogger.Loglevel
Logger using the selected AssertLogger.Loglevel
MethodCallCapturer allows to create stubs for given java types which capture the calls of methods of this stub.MethodCallCapturer creates a new stub instance.MethodCallCapture instance has been captured.MethodCallCapturer.newInstanceOfCapturedTypeWhichIsMethodCallCapturerAware(Class).MethodInterceptor for the MethodCallCapturer.MethodCallCapturer.newInstanceOfCapturedType(Class).MethodInvocationForwardingCapturer allows to create proxies which are put on top of existing object instances.Method and arguments which implements MethodInvocationForwardingCapturer.MethodAndArguments.hashCode() and MethodInvocationForwardingCapturer.MethodAndArguments.equals(Object)MethodInvocationHandlerMethodInvocationHandler which captures a call for the Object.toString() method and forwards all other
invocations.MethodInvocationHandler which captures a call for the UnderlyingMapAware.getUnderlyingMap() methodClass.getMethods() for a given Class.
Map with the referenced Method.getName()s as keys and the respective
BeanMethodInformation name.
Map with all Method.getName()s and the respective BeanMethodInformation instances.
Map with all Methods of a given Class and the annotation instance for the given method.
Map of all Methods of the given Class type and a List of declared
Annotations related to the Methods
Map of all the given Methods and a List of declared Annotations related to the
Methods
Map with Methods of the given type and the return type of the Methods
Map with all the given Methods and their return type
Enum.name() method which is the only method which can be shared across several
Enum implementations without conflicts.Name
TokenMonoHierarchy.Navigator to the given child token element.
TokenMonoHierarchy.Navigator to the given child token element.
TreeNode at the given index position
TokenMonoHierarchy.Navigator to the first child token element.
TreeNode
TreeNode
TokenMonoHierarchy.Navigator.hasValues().
TreeNode sibling with the given relative index position.
TreeNode sibling.
TokenMonoHierarchy.Navigator to its parent
TreeNode
List of ByteArrayContainersBeanPropertyAccessor which has the given BeanPropertyAccessor.PropertyAccessType set.
CachedElement.CachedValue instance.
PreparedBeanCopier.CopierFactory.Copier instance for the given Class type
ElementConverter which converts from a given xml content String to an Object of the
given type
ListToTypeAdapter for a given List with the given Class as facade.
ListToTypeAdapter for a given List with the given Class as facade.
ListToTypeAdapter for a given List with the given Class as facade.
ListToTypeAdapter for a given List with the given Class as facade.
ListToTypeAdapter for a given List with the given Class as facade.
PropertynameMapToTypeAdapter for a given Map with the given Class as
facade.
PropertynameMapToTypeAdapter for a given Map with the given Class as
facade.
SourcePropertyAccessorToTypeAdapter instance for the given Class based on the given
SourcePropertyAccessor
SourcePropertyAccessorToTypeAdapter instance for the given Class based on the given
SourcePropertyAccessor
Map view on a given Java Bean object.
AutowiredContainer instance
AutowiredContainer for a given Map
Map view on a given Java Bean object.
SortedList instance
Map instance
Map instance
JAXBCollection for a given Collection.
JAXBList for a given List.
Map wrapper.
JAXBSet for a given Set.
Class using a possibly present valueOf method which has the same parameter
signature as the provided arguments.
PreparedBeanCopier.InstanceFactoryCreator.InstanceFactory for the given Class type
Class using a constructor which has the same parameter signature as the provided
arguments.
MethodCallCapturer.
MethodCallCapturer.newInstanceOfCapturedType(Class) but makes the created stub implementing the
MethodCallCapturer.MethodCallCapturerAware interface which allows to get the underlying MethodCallCapturer through the generated
stub.
MethodCallCapturer.MethodCallCapturerAware interface and which generates method returned objects
which are stubs, too.
AutowiredContainer using a regular LinkedHashMap
List instance.
KeyValue instance with inverted first and second value
Tuple2 instance with inverted first and second value
TupleTwo instance with inverted first and second value
Iterator which returns xml content chunks for all xml tags matching the given QName XMLIteratorFactory.newIterator(QName) but allows to specify an additional ElementConverter which post processes the
extracted xml chunks
Classes annotated with JAXB compliant annotations and uses JAXB to create instances of the
given type based on the data of the extracted xml chunks.
XMLIteratorFactory.newIterator(Class) but allows to specify a XMLIteratorFactory.XMLElementSelector to select tags from the xml stream.
XMLIteratorFactory.newIterator(QName, ElementConverter) but allows to specify a more general XMLIteratorFactory.XMLElementSelector
instead of a QName
XMLIteratorFactory.newIterator(QName) but allows to specify a more general XMLIteratorFactory.XMLElementSelector instead of a
QName
Iterator which returns Map entities each based on a single content chunk which are produced for all xml
tags matching the given QName JAXBXMLHelper.JAXBContextBasedUnmarshaller instance.
XMLNestedMapConverter.newMapFromXML(CharSequence)
XMLNestedMapConverter.newNamespaceAwareMapFromXML(CharSequence) but with non Namespace aware String values as
keys.
XMLNestedMapConverter.newNamespaceAwareMapFromXML(CharSequence) and XMLNestedMapConverter.newMapFromXML(CharSequence) which allows
to convert the QName based key values to other representations.
ElementStream of MethodInvocationForwardingCapturer.MethodInvocationAndResult instances from a given InputStream which was
produced by the MethodInvocationForwardingCapturer.newProxyInstanceCapturing(Object, OutputStream) before.
MethodInvocationForwardingCapturer.MethodInvocationAndResult instances within the given Range of the index positions of the
order of invocation.
Map instances which contains all information from the given xml content as key value pairs.
TokenMonoHierarchy.Navigator instance based on the current navigation position.
NodeMap for a given Object which is based on the Java bean properties
NodeMap for a given Map which contains nested further Map instances
NodeMap based on a normal Map containing hierarchical structured keys.
NodeMapFactory.newNodeMapFromHierarchicalKeyMap(Map, String) but having the last hierarchy level put into a Map
which acts as model
Operation instance.
OutputStream as xml.
Class type
StubCreator.newStubInstance(Class, Class[], MethodInterceptor) but uses a MethodInvocationHandler instead.
StubCreator.newStubInstance(Class, Class[], MethodInterceptor) but uses a MethodInvocationHandler instead.
Map
SourcePropertyAccessorToTypeAdapter.Builder.newTypeAdapter(SourcePropertyAccessor) but allows to add further
SourcePropertyAccessorDecorator and MethodInvocationHandlerDecorator instances.
NodeMap allows to specify a structure using a Map hierarchy where all NodeMap instance can hold a
special model which should be accessed by traversing a structure path.NodeMap instancesCopyException which indicates that for a source property no target property has been foundCollection
Fields of a Class.
Methods of a Class.
Object available as ObjectTreeNode.Tree for Object graphsTreeNavigator for ObjectTree and ObjectTreeNodeTreeNode for Object graphsObjectTreeNodeObject type for the given type.
ObjectsBeanPropertyAccessor related to the last method call done from the stub created by the
BeanProperty.newInstanceOfCapturedType(Class) method.
BeanProperty.newInstanceOfCapturedType(Class) method.
MethodName.newInstanceOfCapturedType(Class) method.
TestInterface testInterface = this.methodName.newInstanceOfTransitivlyCapturedType( TestInterface.class );
String[] methodNames = this.methodName.of( testInterface.doSomething( "text value" ),
testInterface.doSomethingPrimitive( "primitive text" ),
testInterface.doTestSubInterface().doCalculateSomething() );
AssertLogger.DirectAssertHandler which allows to handle the failureHandling result of the previous assertions
AssertLogger.DirectAssertHandler which allows to handle the succes result of the previous assertions
Operation offers an Operation.execute(Object) method.OperationBattery allows to use a single operation facade to access a pool of object instances which offers one and
the same method in a multithreaded environment.OperationBattery implementation using a ConcurrentLinkedQueue in combination with a simple round
robin algorithm.Operation which will allow to execute the OperationBlockingToFastRepeatingExecutions.execute(Object) method only once within a given period of time.Operation with a Boolean resultList of Operation instances.OperationOperationDecorator which decorates the Operation.execute(Object) invocation with the use of
ReentrantLock.lock().Operation which uses an internal ExceptionHandlerManager to handle occurring Exceptions.Operation which will catch any occurring Exception and return an ExceptionHandledResultOperation instancesOperation without parameters or return value.OperationIntrinsic instance as Operation instance.Operation which is wrapped with a try catch block catching all Exception derivative types.OperationOperationVoid to OperationElementConverter to the converter pipe
MapUtils.parseString(String, String, String)
LinkedHashMap instance.
Pattern concernsPreparedBeanCopier will prepare reflection based property copy actions for two given Class types in advance.PreparedBeanCopier.CopierFactory.Copier instancesPreparedBeanCopier.Transformer will return new transformed instances for another given instancePreservationAndIgnorationDeclarer allows to specify excluded types and pathes, as well as preserved types and paths.Class type.
Map using String.valueOf(Object) and all submaps indented to a new column.
StringReplacementBuilder within the given value with the
corresponding replacement Strings
Collection element.
CollectionUtils.CollectionTransformerToString.process(Object, StringBuilder) method will be invoked for every element of the processed Collection.
PropertyFile and creates a PropertyFileContent object.PropertyFileContent to disc.Map implementation for fast access on properties via their property keys.Class or interface type which is used as a facade to an
underlying Map<String,?PropertynameMapToTypeAdapter.Builder which allows to create multiple instances based on the same Class type and PropertynameMapToTypeAdapter.Configuration.PropertynameMapToTypeAdapter.Configuration of a PropertynameMapToTypeAdapter includes following settings:PropertynameMapToTypeAdapter.Configuration.setSimulatingToString(boolean)
PropertynameMapToTypeAdapter.Configuration.setUnderlyingMapAware(boolean)
SourcePropertyAccessorToTypeAdapter.Configuration there are several more
settings available, too.PropertyNameTemplate allows to declare a mapping template string which is normally used to map methods of interfaces
to properties of an underlying structure.Map with the referenced field names as keys and a Set of BeanMethodInformation for every
field name.
Set of BeanMethodInformation for every field
name.
BeanPropertyAccessor instances for all Java Bean properties related to at least one
of the given Fields.
BeanPropertyAccessor instances for all Java Bean properties related to at least one
of the given Methods.
BeanPropertyAccessor instances for all Java Bean properties of the given
Class.
Map with all properties of a given Java Bean class and an instance of the given Annotation type if
the respective property does have one.
Map with all property names of the given Java Bean and a Set of all available annotations for the
properties, including the field, getter and setter methods.
Map of property names and their current values for the Java Bean properties determined by the given
property names for the given Java Bean object.
Class and a Set of
BeanPropertyAccessor instances for each type.
List of all property values for the given property names from the given Java Bean object
List of all property values for the given property names from the given Java Bean object
List of the values of all available properties of the given JavaBean object instance.
ProxyDispatcherFactory generates a proxy which will dispatch to a given List of instances implementing the
same shared typeObject to the AutowiredContainer using its Object.getClass() as primary type.
Object to the AutowiredContainer for one or more given Class types.
Object to the AutowiredPropertyContainer.
Objects to the AutowiredContainer.
Map only if there is no equal key already contained within the
Map.
Map only if there is no equal key already contained within the
Map.
Queue as CircularIterator.Range for Long values which can be used as Iterable.Range with a given String expression.
RangedIterable will only iterate over the subset of elements within the given Range of index positions.Factory creating a ReadWriteLock acting fairBoolean.TRUE
Method parameterEventListener instances at the internally hold references to EventProducer instances
ElementConverterRegistration.registerElementConverter(ElementConverter, Class, Class) but using reflection to create a new instance of
the ElementConverter type.
ElementConverterRegistration.registerElementConverterTypeAware(ElementConverterTypeAware) but for non type aware
ElementConverter instances
ElementConverterRegistration.registerElementConverterTypeAware(ElementConverterTypeAware) using reflection to create a new instance.
ElementConverterTypeAware instance at the ElementConverterRegistration
ExceptionHandler
AutowiredContainer
BeanPropertyAccessor instance from the BeanPropertyAccessors container
BeanPropertyAccessor at the given index position
List instance.
TreeList, which is Object.equals(Object) to the given
Object
Set instance.
Map reference for the current Thread.
Set instance reduced by the elements of the given Iterable
Set instance containing the elements of the given Set reduced by the elements of the given
Iterable
AutowiredContainer which are Class.isAssignableFrom(Class) to the given type.
AutowiredContainer which are put into the container with the given primary type.
EventListener instance from the handler.
EventListener instance from the handler.
List instance.
ListUtils.valueOf(Iterable) and ListUtils.removeFirst(List) applied to the new List List is kept unaffected by this operation.
List instance.
TreeNode
CharSequence
Element by a new Element.
Matcher.group(int) for all group index positions of the given map by the corresponding new values given.
Object with the same type.
IterableUtils.IterableReplicator
IterableUtils.IterableReplicator
MethodCallCapturer.
DurationCapture.Interval.
DurationCapture.Interval back to zero.
DurationCapture.Interval instances.
Iterator instance from the current OperationBatteryRoundRobin.operationQueue
Exception which can be assigned to the given Class type.
EventListener event result implementation.Set.retainAll(Collection) on the given Set instance.
Exception which is assignable to the given Class again.
Exception again if ExceptionHandledResult.hasExceptions() is true which shows that at least one Exception
has occurred.
List instance with the same elements of the given Iterable but in reversed order.
List to the next and switches to this List.
List to the previous and switches to this List.
IteratorUtils.roundRobin(Iterator...)
Iterator which calls Iterator.next() of all given Iterators in a round robin way
Runnable.Runnable as CallableByteArrayContainer.writeTo(File) instead
XMLHelper.select(String, Node, ExceptionHandler)
Nodes by a given XPath expression
List.set(int, Object) the value of the given List instance at the given index position to the given element.
List.remove(int) to remove the element from the given index position an returns it.
Set.Set consisting of multiple given Set instances of the same type SetComposite.add(Object) method will add new elements to the Set with the smallest size.ByteArrayContainer to be marked as invalid
SetDecorator decorates an existing Set instance.SetDelta calculates the changes between two given SetsAccessorWritable does point towards
ElementHolderUnmodifiable
List of EventProducer references to the EventHandler.
ExceptionHandler should handle any CopyException and PreparedBeanCopier.NonMatchingPropertyException
Future.isCancelled()
XMLIteratorFactory.JAXBTypeContentConverterFactory which is used to convert xml content to instances of JAXB based
types.
Map for the current Thread
Factory for new Map instances.
MethodInvocationHandler
SourcePropertyAccessor
BeanPropertyAccessor.PropertyAccessType.
BeanPropertyAccessor.setPropertyValue(Object, Object, PropertyAccessType) using all given BeanPropertyAccessor.PropertyAccessTypes
BeanPropertyAccessor.setPropertyValue(Object, Object, PropertyAccessType, ExceptionHandler) using all given
BeanPropertyAccessor.PropertyAccessTypes
BeanPropertyAccessor.PropertyAccessType.
LinkedList.removeFirst() is called as long as the LinkedList.size() exceeds the LimitedLinkedList.getSizeMax()
otherwise the LinkedList.removeLast().
LimitedLinkedList can have.
Set with a specific type to another Set with another specific type using a
ElementBidirectionalConverterList which should underly this class type facade.
Map
Map which should underly this class type facade.
Set typesFuture.get().
Tuple.
Tuple.
Tuple.
Tuple.
XMLInstanceContextFactory, e.g. to replace the current java default stax implementation
by another one like Staxon or Jettison for JSON
XMLInstanceContextFactory
Map.EntryAutowiredContainer
BeanPropertyAccessors container
Elements.
Iterable by iterating over it and counting the elements.
Iterator by iterating over it.
Map or 0 if the given Map reference is null.
CachedElement which uses a SoftReference to cache a value.ListUtils.sorted(Collection, Comparator) using the Comparable interface of the given elements
List instance which is based on the elements of the given Collection and which is sorted using
the given ComparatorComparator is null the natural order is used.
List interface for sorted lists.SortedList which reduces the need to implement all methodsComparable interface
SortedListAbstractListDispatcher but for SortedListsSortedListDispatcher which is based on the ListDispatcher.size() of the represented virtual SortedList.SortedMap implementationSortedMapToSortedMapAdapter is a decorator and adapter which allows to access a given SortedMap using other
types for the values.SortedList which allows to split the whole List into two.SourcePropertyAccessor interface which reduces to a SourcePropertyAccessor.setValue(String, Object, Class, PropertyMetaInformation) and
SourcePropertyAccessor.getValue(String, Class, PropertyMetaInformation) method signature.SourcePropertyAccessorSourcePropertyAccessorDecorator which will listen to Converter annotated Methods.SourcePropertyAccessorDecorator which will listen to DefaultValue annotated MethodsSourcePropertyAccessorDecorator which will convert incoming keys based on a PropertyAccessOptionSourcePropertyAccessorDecorator which will listen to PropertyNameTemplate annotated Methods and
Classes.SourcePropertyAccessorToTypeAdapter will provide an adapter from a SourcePropertyAccessor to any given
Class type.SourcePropertyAccessorToTypeAdapter.Builder for multiple instances based on the same Class type and SourcePropertyAccessorToTypeAdapter.Configuration instance.SourcePropertyAccessorToTypeAdapter.Configuration of a SourcePropertyAccessorToTypeAdapter includes following settings:SourcePropertyAccessorToTypeAdapter.Configuration.setPropertyAccessOption(PropertyAccessOption)
SourcePropertyAccessorToTypeAdapter.Configuration.setRegardingAdapterAnnotation(boolean)
SourcePropertyAccessorToTypeAdapter.Configuration.setRegardedAnnotationScope(RegardedAnnotationScope)
SourcePropertyAccessorToTypeAdapter.Configuration.setRegardingDefaultValueAnnotation(boolean)
SourcePropertyAccessorToTypeAdapter.Configuration.setPropertyAccessOption(PropertyAccessOption) is set to another PropertyAccessOption it is possible to
access the underlying Map keys e.g. with lowercased keys instead of the case sensitive property names.Annotations are scannedStrTokenizer
SortedList at the given index position.
String text by an interval.
DurationCapture.Interval.
DurationCapture.Interval.
DurationCapture.Interval.
DurationCapture.Interval.
PropertyFile to disc.
OutputStream using the JAXBXMLHelper.DEFAULT_ENCODING
OutputStream using the given character encoding
OutputStream using the given character encoding
OutputStream using the given JAXBXMLHelper.MarshallingConfiguration
Appendable using the JAXBXMLHelper.DEFAULT_ENCODING
Appendable using the given encoding.
String using the JAXBXMLHelper.DEFAULT_ENCODING
JAXBXMLHelper.storeObjectAsXML(Object) but allows to specify a JAXBXMLHelper.MarshallingConfiguration instance
String using the JAXBXMLHelper.DEFAULT_ENCODING
String using the given encoding.
StringReplacementBuilder allows to StringReplacementBuilder.add(String, String) pairs of regEx patterns and their replacement
Strings and to StringReplacementBuilder.process(String) values using these pairs.StringsSortedList starting by the given fromElement which will be included in
the sublist and ending by the given toElement which will be excluded from the sublist.
Callable to the given ExecutorService instance and calls FutureTaskManager.manageFutureTask(Future)
for the resulting FutureTask
Runnable to the given ExecutorService instance and calls FutureTaskManager.manageFutureTask(Future)
for the resulting FutureTask
Callable to the internal ExecutorService.
FutureTaskManager.submitAndManage(Callable) but the Callable will be submitted the given number times
FutureTaskManager.submitAndManage(Callable, int) but for Runnable
Callable submits which share the same result typeExecutorService which allows to manage groups of submitted tasks with the same result type.Integer values
Double Iterable.
Integer Iterable.
Set of all supertypes the given type extends.
Iterator instance which has the given iterator index position within the IteratorDecoratorSwitchable.getIteratorList()
IteratorDecoratorSwitchable.switchTo(int) but resolving the right Iterator instance using the given Iterator.
ListIterator instance which has the given list iterator index position within the
ListIteratorDecoratorSwitchable.getListIteratorList()
ListIteratorDecoratorSwitchable.switchTo(int) but resolving the right ListIterator instance using the given ListIterator.
Iterator to the next Iterator
ListIterator to the next ListIterator
List
Iterator instance which returns true for Iterator.hasNext(), but only if the
IteratorDecoratorSwitchable.getActiveIterator() does not return true for Iterator.hasNext() itself already.
ListIterator instance which returns true for ListIterator.hasNext(), but only if the
ListIteratorDecoratorSwitchable.getActiveListIterator() does not return true for ListIterator.hasNext() itself already.
Iterator to the previous Iterator
ListIterator to the previous ListIterator
List
ListIterator instance which returns true for ListIterator.hasNext(), but only if the
ListIteratorDecoratorSwitchable.getActiveListIterator() does not return true for ListIterator.hasNext() itself already.
Cache implementation using a synchronized WeakHashMap.SortedList starting by the given element up to the end including the given element.
ThreadLocal variant of a CachedElement which caches resolved element values for each thread independently.Iterator which uses a ThreadLocal instance to cache resolved elements per
Thread.
Iterator decorator which uses a ThreadLocal to store any element within an internal ThreadLocal
instance.ThreadLocalMap is a Map stored independently for each Thread by using ThreadLocal.ThreadLocal instance to be used as AccessorThreadLocal instance
Iterator delegate which makes use of an internal ReentrantLock to avoid concurrent access of the
underlying Iterator.Exception triggered by the previous assertion
RuntimeException with the assertion as cause
Exception with the assertion as cause
Throwable with the assertion as cause
PreparedBeanCopier.NonMatchingPropertyException if PreparedBeanCopier.hasNonMatchingProperties() is true
RuntimeException triggered by the previous assertion
BeanReplicator
Collection.
Collection into a typed array
Integer Collection as array.
Map containing the Set of elements as keys and the count of each element as value.
Iterable instance for the given CharSequence which uses the given regular expression delimiter
to produce tokens.
TokenMonoHierarchy allows to create hierarchical structures which are based on Lists of elements.TokenMonoHierarchy.Navigator allows to navigate on a given TokenMonoHierarchyTokenMonoHierarchy which has children an one parent.TokenMonoHierarchy.TokenElementPath represents a path of token elementsMap to a List using the given MapUtils.MapEntryToElementConverter to create single elements
for the List based on the Map.Entrys of the given Map
Iterable into a Map using a LinkedHashMap which keeps the order of the
List.
MapUtils.valueOf(KeyExtractor, Iterable)
XMLNestedMapConverter.toXML(Map) but for Map instances having a QName based key type
XMLNestedMapConverter.toXML(Map, OutputStream) but for Maps having QNames as key type
XMLNestedMapConverter.toNamespaceAwareXML(Map, OutputStream) but returns a String instance instead of writing into an
OutputStream
XMLNestedMapConverter.toXMLDocument(Map, OutputStream) but has full qualified QNames
Array for a primitive one
String version of the current PropertyFileContent
String representation of the given Iterable using String.valueOf(boolean)
String representation for a Map
Object.
ObjectUtils.toStringAsNestedHierarchy(Object) but with reduced information
MapUtils.printMapHierarchical(PrintStream, Map) but returning a String value
Map structure
XMLNestedMapConverter.toXML(Map) but writes the result to a given OutputStream directly instead of creating a
String.
XMLNestedMapConverter.toXMLDocument(Map, OutputStream) but returns a String instance instead of writing into an
OutputStream
XMLNestedMapConverter.toXML(Map, OutputStream) but encloses the given nested Map into a xml document with a single root
tag
InputStream to the given OutputStream returning a StreamConnector.TransferResult
TransformerFactory to transform the given xml StreamSource using the given xslt
StreamSource into the StreamResult
XMLEvent based on the given XMLEvent.
Map instance which contains the property names as keys and the values of the properties as map values.
TreeNode and its children transitively invoking TreeNavigator.TreeNodeVisitors for each
TreeNode.
#traverse(TraversalConfiguration, TreeNodeVisitor)
TreeNavigator.traverse(TreeNodeVisitor...) but allows to specify a default TreeNavigator.TreeNodeVisitor.TraversalConfiguration.
Tree acts as a container for a TreeNode object graph.Tree instancesList implementation does use an internal TreeMap to provide all features a SortedSet has,
except the fact that duplicate elements are allowed.TreeList.ElementList is based on an regular ArrayList but additionally removes itself from the underlying
SortedMap if its last element is removed and the List is going to get empty.TreeList.ElementVisitor.TraversalHint affects the traversal over the elements of the TreeListObjectTreeNavigator for the given Object
TreeNavigator allows to navigate on a given Tree.TreeNavigator on top of the given Tree which starts with the Tree.getTreeRootNode() as
navigation origin.
TreeNavigator.TreeNodeVisitor.TraversalControl which affects the local behaviorTreeNodes.TreeNodesTreeNavigator.traverse(TreeNodeVisitor) methods.TreeNavigatorTree.TreeHelper.treeNodeToChildrenTreeNodeListMap(Tree) but for the model of the TreeNodes
TreeNodes.
Map containing all TreeNodes of the hierarchy of a given Tree mapped to a List of
all children TreeNodes for each key node.
Tuple is the marker interface for generic wrapper classes holding arbitrary elements of different numbers.Tuple supporting Tuple2.hashCode(), Tuple2.equals(Object) and Tuple2.toString() using the values of
the given elements.Tuple2 instance based on the values of an already existing instance
Tuple holding three data instances.Tuple3 insteadTuple2 insteadTupleTwo instance based on the values of an already existing instance
Class of the given instance or null if null is given as instance
Map view on an underlying Java Bean object.Map view on an underlying Java Bean object.Map implementation.UnderlyingMapAware interface which relies on Maps with String types as key and Object
as valueMap in the respective JavaBean
AutowiredContainerDecorator which prohibits modifications to the underlying AutowiredContainer.
EventListener from the EventProducer instances
ExceptionHandler
URL related actionsAutowiredContainer instance based on the elements of a given Iterable
Array based on the given Collection and the given array component typeCollection null is returned, too.
Array based on the given Iterable and the given array component typeIterable null is returned, too.
Array instance based on the Class types of the given elements.
ArrayList instance containing the elements of a given Iterable
List instance for a given Iterator
List instance for all the elements up to the given end index position based on the given
Iterator.
List instance for all the elements between the two index position boundaries based on the given
Iterator.
List instance for a given ElementStream
ListUtils.valueOf(Iterable) for one or more elements
SetUtils.valueOf(Iterable) for one or more elements
SetUtils.valueOf(Iterable)
LinkedHashSet instance with the element of the given Iterable which keeps the order of the
elements
ByteArrayContainer instance mapping the same byte[] array as the given ByteArrayContainer
Iterable on an ElementStream
Iterable based on a given Factory for Iterators
Iterable which returns the given Iterator instance
Iterable over the given elements
Factory of Iterator instances which is based on an internal List buffer which will contain
the elements of the given Iterator.
Iterator instances of the given Iterables.
ListIterator instances of the given Lists.
Iterator instance for the given elements
Map instance for the given Iterable using the given KeyExtractor to extract every key
one by one from the Iterable
Map instance for the given Iterable using the ElementConverterElementToMapEntry
instance to convert every element to an Map.Entry
List of the Iterators related to the given Iterables
Collection of all values within the Cache which only represents a snapshot in moment
TreeNodes
List of the internal SortedMap.values()TreeList.visitElements(ElementVisitor, Iterable) which uses all available TreeList.ElementList instances of the
internal SortedMap in their sort order.
TreeList.ElementList in their current order and execute the
TreeList.ElementVisitor.beforeTraversalOfElementList(int, int, List) on them.
Waiter allows to wait for the results of a SubmitGroup and allows to reduce the result into further forms.Future.get() to wait on all managed Futures until they are finished
Future to finish.
CachedElement which uses a WeakReference to cache a value.MapJoiner.JoinResult using a given MapJoiner.Predicate
PropertyFileContent as String
ByteArrayContainer to the given File
ByteArrayContainer to the given Writer instance.
ByteArrayContainer.writeTo(Writer, String) using the default encoding "utf-8"
ByteArrayContainer to an Appendable e.g. a StringBuilder or
StringBuffer
ByteArrayContainer to a given OutputStream without closing the OutputStream
but flushing the content to it.
XMLHelper for XPath or Document based helper methods.TransformerFactoryXMLInstanceContextFactory implementation using the Java default StAX providerXMLInstanceContextFactory which uses StAXON to generate any new instancesXMLIteratorFactory is a wrapper around StAX and JAXB which allows to split a given xml InputStream content
into Object, Map or String content chunks.XMLIteratorFactory does not close the underlying InputStream
XMLIteratorFactory.XMLIteratorFactory(InputStream, ExceptionHandler) using an ExceptionHandlerIgnoring
XMLIteratorFactory.XMLElementSelector which matches a given QNameXMLIteratorFactory.XMLEventTransformer which allows to transform the tag and attribute names.XMLIteratorFactory.XMLEventTransformerForTagAndAttributeName.XMLTagAndAttributeNameTransformer which removes any Namespace from xml tag and attributesXMLNestedMapConverter allows to convert xml content into a nested Map hierarchy.
|
||||||||||
| PREV NEXT | FRAMES NO FRAMES | |||||||||