All Classes and Interfaces

Class	Description
AbstractBinder	Base implementation of a binder. Manages the binder's listeners, the binding properties, and the validation scope.
AbstractBinding	Common implementation of a binding.
AbstractBindingFactory	Base implementation of a binding factory. Creates DefaultBindingMembers and, unless configured otherwise via AbstractBindingFactory.putBindableElementClass(Class, Class), DefaultBindableElements.
AbstractClassMapper<S>	Base implementation for class mappers. Implements lenient (superclass/interface) and package (class base names) lookup.
AbstractConnection	Base class of a connection.
AbstractConnectionPool	Base class for connection pools. The pooling parameters are optionally defined in the URI query string: initial: the initial pool size (default 1) increment: the number of connections to add if all are in use (default 1) minimum: the minimum pool size (default 1) maximum: the maximum pool size (default 0, i.e. unlimited) idle: the idle timeout in minutes (default 10) usage: the maximum usage time in minutes (default 0, i.e. unlimited)
AbstractDictionaryBasedTripType<T>	Base class for dictionary-aware trip types.
AbstractInterceptor	An abstract interceptor.
AbstractInterceptorAnnotationProcessor	Processor for annotations annotated with @Interception. Provides annotation checking during compilation and IDE editing.
AbstractKeyring	Base class of the keyrings.
AbstractMappedDiagnosticContext	Base implementation of a mapped diagnostic context.
AbstractObjectValidator<T>	Object validator base class. Object validators have neither a value nor a condition.
AbstractPool<T>	Base implementation of a pool managing Poolable resources. It allows min/max sizes, fixed increments, and timeouts for unused and long-used instances.
AbstractPoolSlot<T>	A slot holding a poolable managed by a pool. While the poolable is lent, the slot holds only a weak reference to it, so that lent but never returned poolables can be detected via AbstractPoolSlot.isUnreferenced().
AbstractPredefinedArrayTripType<T>	Base class for all predefined array types.
AbstractRepeatableValidator<T>	An abstract repeatable validator.
AbstractScope	Base class for validation scope implementations.
AbstractScript	Abstract implementation of a script.
AbstractScriptingLanguage	Common code for scripting languages. Languages are equal if their names are equal.
AbstractScriptValidationMessageConverter	Converts a validator message script.
AbstractServiceAnnotationProcessor	Common implementation for service annotation processors. Provides helper methods to verify the annotated classes and reports abstract classes as errors.
AbstractTask	Base implementation of a task. The task listeners are fired when the dispatcher sets the started and completed timestamps.
AbstractTransport	Base class for transport implementations.
AbstractTripComponentProvider<T>	Base class for TripComponentProvider implementations. Provides the given serializable fields (neither static, transient nor annotated with @TripIgnore) of the class and its superclasses as components.
AbstractTripType<T>	Base class for all trip types.
AbstractValidationResult	Base implementation for validation results.
AbstractValidator<T>	An abstract validator.
Acceptor<T,E>	Similar to Consumer but allows checked exceptions.
AddShortcut	Shortcut to add some value.
AllInterceptorAnnotationProcessor	Processor for all interception annotations in the core package. Applies to interceptors applicable to methods of interfaces extending Interceptable or of classes implementing Interceptable.
AllScope	Validation scope that applies to all scopes. Validators configured with this scope are applied in any effective scope, and an effective scope of this kind applies all validators.
AllScopeImpl	All scope default implementation. Applies to all scopes.
AppendableWriter	A Writer to an Appendable.
ArrayTripType<T>	Fallback for arrays of objects w/o a dedicated trip type. This is the core type for the majority of object arrays.
ArrayTypeBuilder<T>	Builder for array types.
BigDecimalTripType	Trip type for BigDecimal.
BinaryTripType	Trip type for Binary and TBinary.
Bindable	Annotates a member of a class for eligibility in GUI bindings.
BindableCache	Cache for bindable elements per class.
BindableElement	A bindable element.
Binder	The Binder that associates components with object binding paths.
Binding	Binding between a class member and some related component.
BindingEvent	A binding event. Fired to the ToViewListeners and ToModelListeners before the value is transferred between model and view.
BindingEvent.Type	The kind of transfer.
BindingException	Binding exception.
BindingFactory	The binding factory.
BindingMember	A member in the binding chain.
BindingVetoException	ToViewListeners and ToModelListeners may throw a BindingVetoException to inhibit the transfer of data between the view and the model, respectively vice versa.
BlockingByteArrayInputStream	An input stream waiting for data available in a NotifyingByteArrayOutputStream. The data written so far is moved from the output stream into this input stream, i.e. the output stream is reset.
BlockingHolder<T>	A blocking holder.
BooleanArrayTripType	Trip type for Boolean[] array.
BooleanPrimitiveArrayTripType	Trip type for boolean[] array.
BooleanPrimitiveTripType	Trip type for the boolean primitive.
BooleanTripType	Trip type for Boolean.
ByteArrayTripType	Trip type for Byte[] array.
BytePrimitiveArrayTripType	Trip type for byte[] array.
BytePrimitiveTripType	Trip type for the byte primitive.
ByteTripType	Trip type for Byte.
CallHandler	Handles a remote call. Runs in a regular thread.
CanonicalBuilder	Annotation to mark a class or one of its constructors being constructed by a builder.
CanonicalConstructor	Annotation to mark a constructor as a canonical constructor. Either the constructor's parameters are annotated with CanonicalName or the corresponding members must be annotated with CanonicalField or CanonicalGetter.
CanonicalField	Annotation to mark a field as an argument for a canonical constructor.
CanonicalGetter	Annotation to mark a method as a getter to provide an argument for a canonical constructor. The method must be public and have no parameters.
Canonicalizer<T>	Utility to canonicalize objects.
CanonicalName	Annotation to mark a parameter with a canonical name. Necessary to derive the parameter name via reflection, unless the code was compiled with the javac -parameters option, which we don't want to require for Tentackle applications.
ChainedProperties	Properties with defaults for TRIP.
Changeable	The annotated element is changeable.
ChangeableBindingEvaluator	Annotations used to determine whether a UI-component is changeable must implement this interface.
ChangeableContainer	Repeating container annotation for Changeable.
ChangeableImpl	Implementation of the Changeable-validator.
ChangeableScope	Validation scope for the changeable attribute of UI components.
ChangeableScopeImpl	Changeable scope default implementation.
CharacterArrayTripType	Trip type for Character[] array.
CharacterPrimitiveArrayTripType	Trip type for char[] array.
CharacterPrimitiveTripType	Trip type for the char primitive.
CharacterTripType	Trip type for Character.
ClassArgConstructorVisitor	A visitor for constructors with a single argument of a given class or one of its subtypes.
ClassMappedListener	Listener invoked when a class is mapped the first time.
ClassMapper	Maps names or classes to classes.
ClassMapperFactory	Factory for ClassMappers.
ClassToServicesMapper<T>	Maps a class or interface to a list of service classes. Used for mapped services to collect all services in the classpath, not only the first.
ClassTripComponent<P>	A TripComponent implementation for a class component type. Used for the interfaces of dynamic proxies and the component type of arrays.
ClassTripType	Trip type for Class.
ClientTransportCloseRequest	Return values of remote calls can implement this interface. It is used to programmatically request the client to release or close the transport(s) after having received the return value of a remote method invocation.
CollectionTripType<T>	Trip type for Collections.
CollectionTripType.CollectionHeader<T>	Returned by CollectionTripType.readHeader(TripStream, OpCode).
CollectionTypeBuilder<T>	Builder for collection types.
CommandLine	Command line arguments and options.
CompositePreferences	User- and System-Preferences combined.
CompoundValue	A compound value.
CompoundValue.Type	The value type of strings.
CompressedEncryptedTransport	Transport implementation for compressed and encrypted TCP. Uses a Cryptor for symmetric encryption.
CompressedInputStream	Stream to read compressed data from the underlying input stream.
CompressedOutputStream	Stream to write compressed data to the underlying output stream.
CompressedSslTransport	Transport implementation for compressed SSL over TCP. Packets smaller than the URI query parameter mincompress (default 1024) are not compressed.
CompressedTransport	Transport implementation for compressed TCP. Packets smaller than the URI query parameter mincompress (default 1024) are not compressed.
ConcurrencyHelper	Methods related to concurrency and multithreading.
Connection	An outgoing connection from a client to a server.
ConnectionHandler	Handler for a new incoming connection.
ConnectionPoolSlot	A pool slot holding a TRIP client Connection. An unused connection that has been closed is obsolete and will be removed from the pool.
Convertible<T>	A convertible object.
CopyOnWriteCollection<E>	A copy-on-write wrapper for collections. The first modifying operation creates a clone to leave the original collection untouched.
CopyOnWriteCollection.ReadOnlyIterator<E>	Wrapper for an iterator that forbids invocations of the remove() method.
CopyOnWriteList<E>	A copy-on-write wrapper for lists. The first modifying operation creates a clone to leave the original list untouched.
CopyOnWriteList.ReadOnlyListIterator<E>	Wrapper for a list iterator that forbids modifying method invocations.
CopyOnWriteSet<E>	A copy-on-write wrapper for sets. The first modifying operation creates a clone to leave the original set untouched.
CsvConverter	Converts values to or from a string separated by delimiters. Implements RFC 4180 as well.
DaemonSupervisor	A supervisor controlling the life cycle of daemons.
DaemonSupervisor.TerminationInfo	The daemon termination info.
DateFilter	Filter to prepare dates with separators for the NumberShortcut.
DateTimeUtilities	Utility methods related to the java.time API.
DateTripType	Trip type for Date.
DecryptingInputStream	Stream to read encrypted data from the underlying input stream.
DefaultBindableCache	Default implementation of the cache for bindable elements per class.
DefaultBindableElement	A bindable element.
DefaultBindingMember	Default implementation of BindingMember.
DefaultClassMapper	A default implementation of a class mapper. The map is either initialized from a map, a Properties-object, which in turn could be loaded from a properties file, an XML-file or constructed at runtime, or from the mapped services found by the ServiceFactory.
DefaultClassMapperFactory	The default class mapper factory.
DefaultDeserializer	Default implementation of a low-level deserializer.
DefaultDictionary	Default implementation of a dictionary.
DefaultDictionaryEntry	Default implementation of a dictionary entry. Entries are equal if their ordinals are equal.
DefaultDictionaryEntryComponent	A component of a dictionary entry.
DefaultInterceptableFactory	Default implementation of an InterceptableFactory. Creates a dynamic proxy with an InterceptableInvocationHandler.
DefaultKeyringFactory	The default keyring factory.
DefaultLogger	Pluggable logger using the standard java logging via java.util.logging.
DefaultLoggerFactory	Default implementation for the logger factory.
DefaultMappedDiagnosticContext	The MDC implementation for the java util logging. Although MDC is not supported by the Java logging API and its formatters, this implementation keeps a thread-local map of properties so that there's no difference to the application concerning the effective logging provider.
DefaultOpCode	Predefined operation codes.
DefaultPreferences	Wraps a java util preferences node into a PersistedPreferences node.
DefaultPreferencesFactory	Factory for Preferences wrapped by PersistedPreferences. Use case is to map invocations of PersistedPreferences by the framework or applications back to the standard java util prefs.
DefaultPropertiesResource	Default properties resource based on FileHelper. The name is first tried as a file and, if there is no such file, as a classpath resource.
DefaultRegistry	The default implementation of Registry.
DefaultRemoteDelegate<T>	The default implementation of a remote delegate.
DefaultScope	The default validation scope.
DefaultScriptFactory	Default implementation of a script factory.
DefaultSerializer	Default implementation of a low-level serializer.
DefaultSeverity	The default severity. Applies if a validator does not configure a severity.
DefaultSeverityImpl	Implements the default severity.
DefaultTaskDispatcher	A thread executing tasks in a serialized manner.
DefaultTaskDispatcherLock	Lock for the DefaultTaskDispatcher.
DefaultTransportManager	Default implementation of a TransportManager. Transports are leased: each request increments a lease counter, each release decrements it.
DefaultTripFactory	Default implementation of a trip factory.
DefaultTripStream	Default implementation of a TripStream.
DefaultTripTypeBuilderFactory	The default type builder factory. Multidimensional arrays are built by the builder for Object[], dynamic proxies by the one for Proxy.
DefaultValidationContext	Default implementation of a validation context.
DefaultValidationContextFactory	Default implementation of a ValidationContextFactory.
DefaultValidationScopeFactory	Default implementation of a validation scope factory.
DefaultValidationSeverityFactory	Default implementation of a validation severity factory.
DefaultValidatorCompoundValueFactory	Default compound value factory for validators.
DelegateDescriptor	Delegate descriptor returned if the return value of a remote call is itself a remote object.
Deserializer	Low-level deserializer for primitive values and raw bytes.
DiagnosticUtilities	Utilities for diagnostic purposes.
Dictionary	Dictionary of the classes sent over the wire.
DictionaryEntry	Dictionary entry. Maps an ordinal to an object class along with optional components defining a contract for a stream. Sent over the wire as a simple DTO. Only concrete classes and records become part of the dictionary, no abstract classes and no interfaces.
DictionaryEntryComponent	A component of a dictionary entry.
DictionaryEntryTripType	Trip type for DictionaryEntry.
DisallowedTripType<T>	Trip type for disallowed types. This type is used to programmatically prevent instances of certain classes to be deserialized. The application usually replaces ObjectTypeBuilder with its own builder, which checks for allowed classes and returns this type for all others.
DoubleArrayTripType	Trip type for Double[] array.
DoublePrimitiveArrayTripType	Trip type for double[] array.
DoublePrimitiveTripType	Trip type for the double primitive.
DoubleTripType	Trip type for Double.
DummyDelegate	Marker interface for dummy delegates. Allows Mixins with a valid delegate class to be treated as dummy mixins.
EchoTransceiver	Echoing transmitter/receiver for low-level serializing/deserializing w/o a transport layer.
EffectiveClassProvider<T>	An object that provides the effective class.
EncryptedTransport	Transport implementation for encrypted TCP. Uses a Cryptor for symmetric encryption.
EncryptingOutputStream	Stream to write encrypted data to the underlying output stream.
EnumMapTripType<T>	Trip type for EnumMaps.
EnumSetTripType<T>	Trip type for EnumSets.
EnumTripComponent<T>	A TripComponent implementation for enums.
EnumTripType<T>	Fallback for enums w/o a dedicated trip type. This is the core type for the majority of enums.
EnumTypeBuilder<T>	Builder for enum types.
Equal	The annotated element must be equal to another value.
EqualContainer	Repeating container annotation for Equal.
EqualImpl	Implementation of the Equal-validator.
Fail	The validation results must contain at least one failed result. Used to abort the validation with a ValidationFailedException.
Fail.Results	Type of validation results collected so far.
FailContainer	Repeating container annotation for Fail.
FailedValidationResult	Simple failed result. Created by the MajorSeverity.
FailImpl	Implementation of the Fail-validator.
False	The annotated element must be false.
FalseContainer	Repeating container annotation for False.
FalseImpl	Implementation of the False-validator.
FastCompressedOutputStream	A compressed output stream using the fastest compression level. Best suited for network traffic, where latency matters more than the compression ratio.
FieldTripComponent<P,T>	A TripComponent implementation for fields.
FloatArrayTripType	Trip type for Float[] array.
FloatPrimitiveArrayTripType	Trip type for float[] array.
FloatPrimitiveTripType	Trip type for the float primitive.
FloatTripType	Trip type for Float.
FormatHelper	Formatting helper methods.
FormatHelper.Patterns	Patterns to initialize formatting.
Greater	The annotated element must be greater than another value.
GreaterContainer	Repeating container annotation for Greater.
GreaterImpl	Implementation of the Greater-validator.
GreaterOrEqual	The annotated element must be greater than or equal to another value.
GreaterOrEqualContainer	Repeating container annotation for GreaterOrEqual.
GreaterOrEqualImpl	Implementation of the GreaterOrEqual-validator.
HiddenInterceptorAnnotationProcessor	Processor for the hidden interception annotations in the core package. Applies to interceptors applicable to methods of classes implementing Interceptable only.
Holder<T>	A generic consumer and supplier to hold some object. Useful in lambdas if some data has to be set within the enclosing method.
I18NTextTripType	Trip type for I18NText.
Identifiable	Objects that can be identified by an ID.
IdentifiableKey<T>	Key for an Identifiable. Composed of the class and the ID.
IdentifiableMap<T>	A map of Identifiables.
IdentifiedRemoteCall	The indexed remote call. Used when the method's index is known, i.e. after the first invocation of the method (see InitialRemoteResponse.methodIndex()).
IdentifiedRemoteResponse	The response of an indexed remote call.
IdSerialNameTuple	A tuple holding the ID, serial and name of an object. There is no further logic.
IdSerialTuple	A tuple holding the ID and the serial of an object. There is no further logic.
Immutable	Objects implementing this interface may be mutable or immutable.
ImmutableArrayList<E>	An enhanced ArrayList. Implements Immutable.
ImmutableCollection<E>	Enhanced collection.
ImmutableCollectionTripType<T>	Trip type for immutable collections.
ImmutableException	Runtime exception thrown on an attempt to modify an immutable object.
ImmutableMapTripType<T>	Trip type for immutable maps.
IndexedMethodCache	A cache to access methods of a class by an index. There is one such cache per class. The cache is thread-safe.
InfoValidationResult	Simple informational result. Created by the MinorSeverity.
InheritableThreadLocalHashTable<K,V>	A thread-inheritable thread-local hashtable.
InitialRemoteCall	The remote call. Used when the method is called the first time on the remote object.
InitialRemoteResponse	The remote call's response.
InstantTripType	Trip type for Instant.
IntegerArrayTripType	Trip type for Integer[] array.
IntegerPrimitiveArrayTripType	Trip type for int[] array.
IntegerPrimitiveTripType	Trip type for the int primitive.
IntegerTripType	Trip type for Integer.
InteractiveScope	Validation scope for user interaction.
InteractiveScopeImpl	Interactive scope default implementation.
Interceptable	Marker interface making objects interceptable. Interceptables are usually interfaces instantiated by a dynamic proxy.
InterceptableFactory	Factory to create interceptable objects.
InterceptableInvocationHandler<T>	Invocation handler for Interceptables.
InterceptableMethod	A method wrapper to optionally invoke the interceptors around a delegate's method.
InterceptableMethodCache	A method cache for InterceptableInvocationHandlers.
InterceptableMethodInvoker	Invoker for InterceptableMethods. Optionally logs and counts method invocations. There is one invoker per interceptable type, e.g.
Interception	Annotation to mark another annotation as an interception.
Interception.Type	the interceptor type.
InterceptionAnnotationProcessor	Processor for the @Interception annotation. Provides annotation checking during compilation and IDE editing.
InterceptionService	Annotation to express that the annotated class implements an Interceptable interface.
InterceptionUtilities	Utility methods for interception handling.
Interceptor	A method interceptor.
InvocationTargetExceptionComponentProvider<T>	Component provider for InvocationTargetException.
InvocationTargetExceptionInstanceCreator	Instance creator for InvocationTargetException. The target exception can only be passed to the constructor.
JOSTripType	Wrapper type using Java Object Serialization (JOS). This is the last resort if the class cannot be serialized via TRIP, and it is not possible to provide a TripComponentProvider, a CanonicalConstructor, a TripInstanceCreator or an application-specific TripType, for whatever reason.
Keyring	A store for secrets, such as passwords or tokens, kept on the local machine.
KeyringException	Thrown if the credential store cannot be accessed.
KeyringFactory	Factory providing the Keyring.
Killable	A thread that may be killed.
LambdaTripType	Wrapper type for lambdas. By default, lambda serialization is disabled.
Less	The annotated element must be less than another value.
LessContainer	Repeating container annotation for Less.
LessImpl	Implementation of the Less-validator.
LessOrEqual	The annotated element must be less than or equal to another value.
LessOrEqualContainer	Repeating container annotation for LessOrEqual.
LessOrEqualImpl	Implementation of the LessOrEqual-validator.
LocalDateTimeTripType	Trip type for LocalDateTime.
LocalDateTripType	Trip type for LocalDate.
LocaleTripType	Trip type for Locale.
LocalTimeTripType	Trip type for LocalTime.
Log	Annotation to express that the annotated method should be logged. The method's execution time is logged after it returns, if the logging level is loggable.
Loggable	An interface telling whether an object is loggable or not.
Logger	A pluggable logger.
Logger.Level	Logging levels.
LoggerFactory	Factory for pluggable loggers.
LoggerOutputStream	Output stream for a logger. Nice to catch e.printStackTrace(Stream).
LoggingRunnable	A logging runnable. Wraps a runnable and logs its start and duration, if the level is loggable.
LogInterceptor	Implementation for the Log interception. Logs the execution time of the intercepted method.
LongArrayTripType	Trip type for Long[] array.
LongPrimitiveArrayTripType	Trip type for long[] array.
LongPrimitiveTripType	Trip type for the long primitive.
LongTripType	Trip type for Long.
LoopbackCallHandler	Loopback call handler for testing purposes.
LoopbackConnection	Loopback connection for testing purposes.
LoopbackConnectionHandler	Loopback connection handler for testing purposes.
LoopbackConnectionPool	The loopback client connection pool for testing purposes. The connection pool also maintains the server-side transport (since there is only one connection pool maintained by the client-side transport).
LoopbackTransport	Loopback transport for testing purposes.
MajorSeverity	A major severity.
MajorSeverityImpl	Implements the major severity. Creates a FailedValidationResult.
Mandatory	The annotated element is mandatory.
MandatoryBindingEvaluator	Annotations used to determine whether a UI-component is mandatory must implement this interface.
MandatoryContainer	Repeating container annotation for Mandatory.
MandatoryImpl	Implementation of the Mandatory-validator.
MandatoryScope	Validation scope for the mandatory attribute of UI components.
MandatoryScopeImpl	Mandatory scope default implementation.
MappedDiagnosticContext	A mapped diagnostic context. Provides thread-local optional key-value pairs to enhance logging.
MapTripType<T>	Trip type for Maps.
MapTripType.MapHeader<T>	Returned by MapTripType.readHeader(TripStream, OpCode).
MapTypeBuilder<T>	Builder for map types.
MemoryKeyring	A keyring kept in memory.
MessageScriptConverter	Annotation for a script converter for validator messages.
MethodCache	Cache to speed up method lookup by reflection.
MethodStatistics	Method statistics collector. Counts the invocations and durations per method and serviced class.
MethodStatisticsKey	Method key for collecting method statistics.
MethodTripComponent<P,T>	A TripComponent implementation for getter/setter pairs. Used for getters annotated with CanonicalGetter that are not backed by a serializable field, and by TripComponentProviders such as the ThrowableComponentProvider.
MinorSeverity	A minor severity.
MinorSeverityImpl	Implements the minor severity. Creates an InfoValidationResult.
MiscCoreBundle	Bundle for the misc package in tentackle-core.
MissingOffsetHandler	Error handler to add a missing zone offset. Appends the current default offset.
MissingTimeHandler	Error handler to add, expand or insert a missing time.
MissingZoneIdHandler	Error handler to add a missing timezone. Appends the default timezone.
Mixin<T,M>	Mixin to implement dynamic proxies.
Modifiable	Interface for objects that can tell whether they are modified or not.
MutableByteArrayInputStream	A mutable ByteArrayInputStream.
NamedCounter	Thread-safe named counter.
NamedValue<T>	Thread-safe named value.
NoArgsVisitor	A type visitor that checks whether an executable, usually a constructor, takes no arguments.
NotEmpty	The annotated element must not be empty.
NotEmptyContainer	Repeating container annotation for NotEmpty.
NotEmptyImpl	Implementation of the NotEmpty-validator.
NotEqual	The annotated element must not be equal to another value.
NotEqualContainer	Repeating container annotation for NotEqual.
NotEqualImpl	Implementation of the NotEqual-validator.
NotifyingByteArrayOutputStream	A byte array output stream notifying waiting threads when data was written or the stream was reset.
NotInterceptable	Marks a method that the framework itself invokes directly, bypassing the interceptor chain entirely.
NotNull	The annotated element must not be null. Implies that the element is mandatory.
NotNullContainer	Repeating container annotation for NotNull.
NotNullImpl	Implementation of the NotNull-validator.
NotZero	The annotated element must not be 0 (zero).
NotZeroContainer	Repeating container annotation for NotZero.
NotZeroImpl	Implementation of the NotZero-validator.
NowShortcut	Shortcut to replace the value with the current time and/or date.
Null	The annotated element must be null.
NullContainer	Repeating container annotation for Null.
NullImpl	Implementation of the Null-validator.
NumberShortcut	Shortcut to derive a Temporal from a numeric input. The corresponding part is updated and the remaining parts (to the right) are set to their minimum value.
NumberShortcut.WindowProvider	Provides the input windows for year, month and day.
ObjectTripType<T>	Fallback for objects w/o a dedicated trip type. This is the core type for the majority of objects.
ObjectTypeBuilder<T>	Fallback builder for all other object types. Creates a JOSTripType for classes annotated with @TripViaJOS, a LambdaTripType for lambdas, and an ObjectTripType otherwise.
ObjectUtilities	Object utility methods.
OffsetDateTimeTripType	Trip type for OffsetDateTime.
OffsetFilter	Filter to process a zone offset.
OffsetShortcut	Shortcut for a ZoneOffset.
OffsetTimeTripType	Trip type for OffsetTime.
OpCode	Operation Code. The op-code is the first byte of a serialized block and describes how to process the following bytes, up to the next op-code.
OpCodeCategory	Code category to speed up type lookups.
PacketSizedInputStream	An input stream that reads packets with a header holding the packet size. The header is read as 2 bytes, low byte first.
PacketSizedOutputStream	An output stream that writes packets with a header holding the packet size. The header is written as 2 bytes, low byte first.
Pattern	The annotated element must match a regular expression.
PatternContainer	Repeating container annotation for Pattern.
PatternImpl	Implementation of the Pattern-validator.
PersistedPreferences	Persisted Preferences.
PersistedPreferencesFactory	Factory for PersistedPreferences.
PersistenceScope	Validation scope for persistence.
PersistenceScopeImpl	Persistence scope default implementation.
Pool<T>	A pool managing poolable resources.
Poolable<T>	A resource that can be managed by a Pool.
PoolSlot<T>	A slot in a pool.
PoolTimeoutThread	Timeout thread to monitor Pools. There is only one such thread for all pools.
PredefinedArray<T>	Predefined array type.
PredefinedArrayType	Predefined array types. A subcode for the predefined array type op-code.
PreferencesKeyring	A keyring kept in the Java user preferences.
PrimitiveFieldTripComponent<P,T>	A TripComponent implementation for fields of a primitive type.
PrimitiveFieldTripComponent.Kind	The primitive kinds a field can have.
PriorityQueueTripType<T>	Trip type for the priority queues, i.e.
PropertiesResource	Loads properties from some resource and applies them to a Properties object. Implementations must be annotated with @PropertiesResourceService.
PropertiesResourceService	Annotation for PropertiesResources.
PropertiesUtilities	Utility methods for Properties. Properties are loaded via PropertiesResources.
PropertyEvent	Event fired when a property is modified.
PropertyListener	Listener to track property modifications.
PropertyMap<T>	A property map. Provides the functionality of a map for the properties of a bean.
PropertyMapping<T>	Describes the mapping of a property. Properties can be either is/set-pairs or get/set-pairs of methods or some other readonly method.
PropertySupport	Replacement for java.beans.PropertyChangeSupport, which belongs to the java.desktop module since Java 9.
Provider<T,E>	Similar to Supplier but allows checked exceptions.
ProxyTripType<T>	Fallback for dynamic proxies w/o a dedicated trip type. This is the core type for the majority of dynamic proxies.
ProxyTypeBuilder<T>	Builder for dynamic proxy types.
PublicInterceptorAnnotationProcessor	Processor for the public interception annotations in the core package. Applies to interceptors applicable to methods of interfaces extending Interceptable only.
ReconnectedException	Exception thrown if a resource has been reconnected. When an application catches this exception, it indicates that the resource has been reconnected while the cause holds the exception that triggers the reconnection, i.e., the original resource failure.
ReconnectionPolicy<T>	Policy to reconnect a dead resource.
Reconnector	A simple reconnector. Reconnects resources according to their ReconnectionPolicy, either in the current thread (blocking) or in a background thread.
RecordTripComponent<P,T>	A TripComponent implementation for record types. Record components have no default values and are never set individually: the record is created via its canonical constructor.
RecordTripType<T>	Fallback for records w/o a dedicated trip type. This is the core type for the majority of records. Since records are immutable, all their components must be known before a record can be instantiated.
RecordTypeBuilder<T>	Builder for record types.
Reference<T>	A reference to an object within a stream.
ReferenceTripType	Sends an object reference as a compact reference ID of 1 to 4 bytes.
ReflectionHelper	Methods related to the reflection API.
ReflectionHelper.CanonicalBuilderInfo	The canonical builder info.
ReflectiveVisitor	A reflective visitor to add application-specific functionality to existing objects.
Registry	Registry for remote delegates. All remote delegates must be registered at the registry before their target object can be used as a remote object.
Remote	Interface for remote objects.
RemoteCall	Interface for remote calls.
RemoteDelegate<T>	A remote delegate. Receives calls from the remote side, invokes the methods on the target object and returns the results.
RemoteInvocationHandler	The invocation handler for remote interfaces.
RemoteLookup	Remote interface to look up named remote objects. Implemented by the server's Registry, which is always available under Registry.REGISTRY_ID.
RemoteResponse	Interface for remote responses.
RemoteRoot	The root of a remote object tree. The delegates of remote objects are automatically unregistered if their parent delegates are unregistered.
RemoteService	Annotation to express that the annotated class is an implementation of a remote interface.
RepeatableValidation	Annotation to mark another annotation as a repeatable container annotation for a validation annotation.
RepeatableValidator	The repeatable container validator.
Scavenger	Interface for cleanup services like cleanup threads.
ScopeConfigurator	A configurator for default scopes.
Script	A generic script.
ScriptConverter	Converts a script according to a given language. Used to translate application-specific shortcuts before the script is compiled.
ScriptFactory	A factory for scripts.
ScriptingLanguage	Interface tentackle scripting languages must implement.
ScriptRuntimeException	Script exception.
ScriptVariable	Script variable. Variables are identified by their name, i.e. equality refers to the name only.
ScrollableResource<T>	A scrollable resource. A ScrollableResource is a wrapper around a resource.
Secret	A confidential character sequence, such as a password or an access token.
SecretId	The identity of a secret in a Keyring.
SecretsHelper	Converts secrets between characters and UTF-8 bytes without ever creating a String.
Serializer	Low-level serializer for primitive values and raw bytes.
SerialNumbered	Identifiable providing a serial number.
ShortArrayTripType	Trip type for Short[] array.
ShortLongText	A short and a long text.
ShortPrimitiveArrayTripType	Trip type for short[] array.
ShortPrimitiveTripType	Trip type for the short primitive.
ShortTripType	Trip type for Short.
Size	The annotated element size must be between the specified boundaries (included).
SizeContainer	Repeating container annotation for Size.
SizeImpl	Implementation of the Size-validator.
SmartDateTimeParser<T>	Parser for Temporal date and time types with smart syntax support.
SmartDateTimeParser.ErrorHandler	Parse exception handler.
SmartDateTimeParser.Shortcut	Shortcut for date- or time input.
SmartDateTimeParser.TextFilter	Filter applied to the input. Returns the possibly modified text.
SmartDateTimeParser.TextRange	A part within a string.
Snapshotable<T>	Interface for objects providing the snapshot functionality.
SocketAcceptLoop	The server socket accept-loop for incoming TCP connections.
SocketChannelDispatcher	A simple implementation of a dispatcher accepting incoming socket channels from client connections.
SortedMapTripType<T>	Trip type for SortedMaps, i.e.
SortedSetTripType<T>	Trip type for SortedSets, i.e.
SslParameters	Resolves the SSL/TLS configuration for the TCP socket factories.
SslTransport	Transport implementation for SSL over TCP.
StackTraceElementTripType	Trip type for StackTraceElement.
StatisticsResult	Statistics result for execution count and durations.
StringArrayTripType	Trip type for String[] array.
StringTripType	String type.
SubString	A segment of string. Describes a substring by its indexes within a string. The substring itself is built lazily, thus allowing index computations without string creations.
SuperTypeVisitor	A type visitor that finds type matches in supertypes as well. The visitor parameter is the class to look for.
Supervisable	A thread being supervised by a DaemonSupervisor.
Task	A task being executed by the TaskDispatcher.
TaskDispatcher	A dispatcher executing tasks in a serialized manner.
TaskDispatcherLock	The lock of a task dispatcher.
TaskException	Runtime exception for tasks and task dispatching.
TaskListener	A listener for Task-related events.
TcpConnection	TCP connection.
TcpConnectionPool	The TCP client connection pool.
TcpServerSocketFactory	A TCP server socket factory with configurable SSL/TLS support.
TcpSocketFactory	A TCP client socket factory with configurable SSL/TLS support.
TcpTransport	Transport implementation for TCP.
TentackleRuntimeExceptionComponentProvider<T>	Component provider for TentackleRuntimeException.
Terminatable	Something that can be terminated gracefully. Useful for Threads.
ThrowableComponentProvider<T>	Component provider for Throwable. The message, cause and stack trace are accessed via their getters, since the JDK's fields are not accessible.
ThrowableTripType<T>	Trip type for Throwable.
ThrowableTypeBuilder<T>	Builder for exception types.
TimeKeeper	A duration.
TimestampTripType	Trip type for Timestamp.
TimeTripType	Trip type for Time.
TimeZoneTripType	Trip type for TimeZone.
ToModelListener	A listener invoked before the binding updates the model with the view's value.
ToViewListener	A listener invoked before the binding will update the view with the model's value.
TrackedArrayList<E>	Implementation of a TrackedList based on an ArrayList.
TrackedList<E>	A List with the ability to tell whether it has been structurally modified.
TrackedListListener<E>	A listener for TrackedList events.
Transport	The transport layer.
TransportClientInfo	The client information.
TransportKey	The Transport key.
TransportManager	Maintains transports.
TransportService	Annotation to express that the annotated class is an implementation of a Transport.
TripComponent<P,T>	Describes a component within a class, record, or enum.
TripComponentProvider<T>	Provides the components of a type. Implementations must be annotated with TripComponentProviderService.
TripComponentProviderService	Annotation to express that the annotated class is the TripComponentProvider for the given class.
TripConstants	Some constants used in the Trip protocol.
TripDeduplicatable	Annotation to define whether instances of the annotated class are subject to deduplication or not.
TripError	Special kind of TripRuntimeException used in conjunction with OpCodeCategory.ERROR.
TripFactory	Factory for creating various TRIP objects.
TripFilter	Decides which components of an object are serialized.
TripIgnore	Annotation to mark a field or method to be ignored by TRIP.
TripInstanceCreator<T>	Creates an instance of a class. Must be annotated with TripInstanceCreatorService. Instance creators are used if there is no public no-arg constructor, and it is not possible to define a CanonicalConstructor.
TripInstanceCreatorService	Annotation to express that the annotated class is a creator for the given class. This is a workaround for classes that don't provide a no-args constructor but cannot be annotated with CanonicalConstructor since they are 3rd party or cannot be modified for other reasons. The annotated class must implement the TripInstanceCreator interface for the given class.
TripInstantiationException	Trip instantiation exception. This exception is thrown if an object to be serialized or deserialized cannot be instantiated.
TripNoSuchDelegateException	Trip exception if a remote delegate is not registered.
TripObjectSerializer	Object serializer using the TRIP serialization format. The serialized data is self-contained, i.e. it includes the dictionary entries.
TripReferencable	Annotation to define whether the annotated class is referencable or not.
TripRuntimeException	Trip runtime exception.
TripSerializable	Annotation to define whether instances of the annotated class are serializable or not.
TripSerializeLambda	Annotation to express that serializing lambdas is enabled for the annotated class.
TripStream	The stream to read and write trip objects.
TripStreamClosedException	Trip stream closed exception.
TripType<T>	A serializable data type. The trip type applies to the local JVM only and is never sent over the wire. Notice: TripTypes are singletons and must not maintain any state to provide thread-safety!
TripTypeBuilder<T>	Creates a TripType for a given concrete class. Type builders are used to create the concrete TripTypes for all data types without a predefined or application-specific type. Notice: TripTypeBuilders are singletons and must not maintain any state to provide thread-safety!
TripTypeBuilderFactory	A factory for TripTypeBuilders.
TripTypeBuilderService	Annotation to express that the annotated class is a TripTypeBuilder for implementations of given interface or extensions of given class.
TripTypeCategory	Type category.
TripTypeService	Annotation to express that the annotated class is an implementation of a TripType.
TripViaJOS	Annotation to express that the annotated class must be serialized via the old-school Java Object Serialization (JOS).
True	The annotated element must be true.
TrueContainer	Repeating container annotation for True.
TrueImpl	Implementation of the True-validator.
UriHelper	Some URI helper methods.
UserHomeJavaDir	The tentackle directory within the user's home. Used to cache files, such as preferences, keyrings or downloaded updates.
UUIDTripType	Trip type for UUID.
Validate	Validates a component of the object. There are 2 use-cases for this annotation: Validate the contents of an application-specific datatype.
Validateable	An object that provides its own validation.
ValidateContainer	Repeating container annotation for Validate.
ValidateImpl	Implementation of the Validate-validator.
Validation	Annotation to mark another annotation as a validation annotation and to establish a link between the validation annotation and the validator implementation.
ValidationContext	The validation context.
ValidationContextFactory	Factory for validation contexts.
ValidationEvent	A validation event. Fired after a binding has been validated.
ValidationFailedException	Exception thrown if a validation fails logically.
ValidationListener	A listener that gets invoked after a binding has been validated.
ValidationMapper	A mapper to translate validation paths to binding paths.
ValidationResult	The result of a validation.
ValidationResult.CollectionIndex	A collection index within a validation path.
ValidationRuntimeException	Exception thrown to indicate that the validation could not be applied.
ValidationScope	A validation scope.
ValidationScopeFactory	Factory for validation scope singletons.
ValidationScopeService	Annotation to express that the annotated class is an implementation of a validation scope.
ValidationScriptConverter	Annotation for a script converter for value and condition scripts of validators.
ValidationSeverity	A severity associated with a failed validation. Applications may define their own severities or replace the default ones in order to create application-specific validation results.
ValidationSeverityFactory	Factory for validation severity singletons.
ValidationSeverityService	Annotation to express that the annotated class is an implementation of a validation severity.
ValidationUtilities	Utilities for validation.
ValidationUtilities.MapResult	Mapping result from ValidationUtilities.mapValidationPath(NavigableSet, Binder, String).
ValidationUtilities.ValidatorKey	Key to identify a validator of a field or method. Since the validation index is unique per class, field and method annotations of the same attribute get different keys and are both applied.
Validator	A validator.
ValidatorBundle	Bundle for validators in tentackle-core.
ValidatorCache	Holds all fixed validators cached for all classes.
ValidatorCompoundValueFactory	Factory to create CompoundValues for validators.
ValidatorList	A list of validators.
VolatileHolder<T>	Same as Holder, but with a volatile object reference. Useful if the object is set and retrieved by different threads.
WrappedCollectionTripType<T>	Trip type for JDK collections that provide no usable constructors, such as the Collections wrappers (unmodifiable, empty, singleton) and Arrays.asList(T...).
WrappedMapTripType<T>	Trip type for JDK maps that provide no usable constructors, such as the Collections wrappers (unmodifiable, empty, singleton).
WrappedSortedMapTripType<T>	Trip type for the Collections wrappers of sorted maps, i.e.
WrappedSortedSetTripType<T>	Trip type for the Collections wrappers of sorted sets, i.e.
XUUID	Extended UUID. An XUUID is a combination of an ID and a UUID.
Zero	The annotated element must be 0 (zero).
ZeroContainer	Repeating container annotation for Zero.
ZeroImpl	Implementation of the Zero-validator.
ZonedDateTimeTripType	Trip type for ZonedDateTime.
ZoneFilter	Filter for timezones.
ZoneShortcut	Shortcut for a ZoneId.