All Classes and Interfaces
Class
Description
Encodes a string into a Caverphone value.
Base class for circuit breakers.
An internal enumeration representing the different states of a circuit
breaker.
Deserializer only used for abstract types used as placeholders during polymorphic
type handling deserialization.
Abstract class that is used to execute an arbitrary
method that is introspected.
Abstract class that is used to execute an arbitrary 'get' method.
Abstract class that is used to execute an arbitrary method.
A helper class to pass the method & parameters.
Abstract class that is used to execute an arbitrary 'set' method.
Defines interface for resolvers that can resolve abstract types into concrete
ones; either by using static mappings, or possibly by materializing
implementations dynamically.
API for handlers used to "mangle" names of "getter" and "setter" methods to
find implicit property names.
Helper class that implements all abstract methods with dummy implementations.
Interface for provider (factory) for constructing
AccessorNamingStrategy
for given type of deserialization targetEnumeration used to indicate required access pattern for providers:
this can sometimes be used to optimize out dynamic calls.
Deprecated.
as of 3.6, use commons-text
AggregateTranslator instead
Shared base class used for anything on which annotations (included
within a
AnnotationMap).Silly little "Pair" class needed for 2-element tuples (without
adding dependency to one of 3rd party packages that has one).
Helper class that contains logic for resolving annotations to construct
AnnotatedClass instances.Object that represents non-static (and usually non-transient/volatile)
fields of a class.
Intermediate base class for annotated entities that are members of
a class; fields, methods and constructors.
Simple helper class used to keep track of collection of
AnnotatedMethods, accessible by lookup.Object that represents method parameters, mostly so that associated
annotations can be processed conveniently.
Intermediate base class that encapsulates features that
constructors and methods share.
Helper class used to collect annotations to be stored as
Annotations (like AnnotationMap).Immutable implementation for case where no annotations are associated with
an annotatable entity.
Abstract class that defines API used for introspecting annotation-based
configuration for serialization and deserialization.
Value type used with managed and back references; contains type and
logic name, used to link related references
Add-on extension used for XML-specific configuration, needed to decouple
format module functionality from pluggable introspection functionality
(especially JAXB-annotation related one).
Helper class that allows using 2 introspectors such that one
introspector acts as the primary one to use; and second one
as a fallback used if the primary does not provide conclusive
or useful result for a method.
Simple helper class used to keep track of collection of
Jackson Annotations associated with annotatable things
(methods, constructors, classes).
Interface that defines interface for accessing contents of a
collection of annotations.
Helper methods for working with
Annotation instances.Class similar to
BeanPropertyWriter, but that will be used
for serializing JsonAnyGetter annotated
(Map) propertiesAn utility class for the os.arch System Property.
We need a custom deserializer both because
ArrayBlockingQueue has no
default constructor AND because it has size limit used for constructing
underlying storage automatically.Helper class that contains set of distinct builders for different
arrays of primitive values.
Iterator implementation used to efficiently expose contents of an
Array as read-only iterator.
An Iterator wrapper for an Object[].
A class that wraps an array within an AbstractList.
Node class that represents Arrays mapped from JSON content.
Intermediate base class for serializers used for various
Java arrays.
Sorts and returns arrays in the fluent style.
Array types represent Java arrays, both primitive and object valued.
Operations on arrays, primitive arrays (like
int[]) and
primitive wrapper arrays (like Integer[]).Base class for serializers that will output contents as JSON
arrays; typically serializers used for
Collection
and array types.Type deserializer used with
JsonTypeInfo.As.WRAPPER_ARRAY
inclusion mechanism.Type serializer that will embed type information in an array,
as the first element, and actual value as the second element.
A
TypeDeserializer capable of deducing polymorphic types based on the
fields available.Type serializer used with
JsonTypeInfo.As.EXISTING_PROPERTY inclusion mechanism.Type deserializer used with
JsonTypeInfo.As.EXTERNAL_PROPERTY inclusion mechanism.Type serializer that preferably embeds type information as an "external"
type property; embedded in enclosing JSON object.
Type deserializer used with
JsonTypeInfo.As.PROPERTY
inclusion mechanism.Type serializer that preferably embeds type information as an additional
JSON Object property, if possible (when resulting serialization would
use JSON Object).
Deprecated.
Only for use in maintaining binary compatibility - should not actually be used - will be removed in 3.0
Identifiers, variables and registers.
Deprecated.
Only for use in maintaining binary compatibility - should not actually be used - will be removed in 3.0
Enhanced script to allow parameters declaration.
Declares a local variable.
Type deserializer used with
JsonTypeInfo.As.WRAPPER_OBJECT
inclusion mechanism.Type wrapper that tries to use an extra JSON Object, with a single
entry that has type name as key, to serialize type information.
A specialized implementation of the
ConcurrentInitializer interface
based on an AtomicReference variable.
A specialized
ConcurrentInitializer implementation which is similar
to AtomicInitializer, but ensures that the AtomicSafeInitializer.initialize()
method is called only once.VirtualBeanPropertyWriter implementation used for
JsonAppend,
to serialize properties backed-by dynamically assignable attribute
values.Signals a failure processing authentication challenge
This class provides utility methods for parsing HTTP www and proxy authentication
challenges.
This class provides utility methods for processing HTTP www and proxy authentication
challenges.
Signals a failure in authentication process
Authentication policy class.
This interface represents an abstract challenge-response oriented
authentication scheme.
Deprecated.
No longer used
The class represents an authentication scope consisting of a host name,
a port number, a realm name and an authentication scheme name which
Credentials apply to.
Signals fatal error in initialization of
AuthSSLProtocolSocketFactory.
AuthSSLProtocolSocketFactory can be used to validate the identity of the HTTPS
server against a list of trusted certificates and to authenticate to the HTTPS
server using a private key.
AuthSSLX509TrustManager can be used to extend the default
X509TrustManager
with additional trust decisions.This class provides detailed information about the state of the
authentication process.
A class that allows complex initialization operations in a background task.
Provides Base16 encoding and decoding.
Provides Base16 encoding and decoding in a streaming fashion (unlimited size).
Provides Hex encoding and decoding in a streaming fashion (unlimited size).
Provides Base32 encoding and decoding as defined by RFC 4648.
Provides Base32 encoding and decoding in a streaming fashion (unlimited size).
Provides Base32 encoding and decoding in a streaming fashion (unlimited size).
Provides Base64 encoding and decoding as defined by RFC 2045.
Provides Base64 encoding and decoding in a streaming fashion (unlimited size).
Provides Base64 encoding and decoding in a streaming fashion (unlimited size).
Class used to define specific details of which
variant of Base64 encoding/decoding is to be used.
Defines how the Base64Variant deals with Padding while reading
Container for commonly used Base64 variants:
Base64Variants.MIME
Base64Variants.MIME_NO_LINEFEEDS
Base64Variants.PEM
Base64Variants.MODIFIED_FOR_URL
See entries for full description of differences.Abstract base class common to all standard
JsonNode
implementations.Abstract superclass for Base-N encoders and decoders.
Abstract superclass for Base-N input streams.
Abstract superclass for Base-N output streams.
Immutable container class used to store simple configuration
settings for both serialization and deserialization.
Default
BeanDescription implementation used by Jackson.Abstract factory base class that can provide deserializers for standard
JDK classes, including collection classes and simple heuristics for
"upcasting" common collection interface types
(such as
Collection).Helper class to contain default mappings for abstract JDK
Collection
and Map types.Helper class to contain largish number of parameters that need to be passed
during Creator introspection.
Standard
BasicPolymorphicTypeValidator implementation that users may want
to use for constructing validators based on simple class hierarchy and/or name patterns
to allow and/or deny certain subtypes.Builder class for configuring and constructing immutable
BasicPolymorphicTypeValidator instances.General matcher interface (predicate) for validating unresolved
subclass class name.
General matcher interface (predicate) for validating class values
(base type or resolved subtype)
Basic authentication scheme as defined in RFC 2617.
Factory class that can provide serializers for standard JDK classes,
as well as custom classes that extend standard classes or implement
one of "well-known" interfaces (such as
Collection).
An implementation of the
ThreadFactory interface that provides some
configuration options for the threads it creates.
A builder class for creating instances of
BasicThreadFactory.Identical to the Base64 encoding defined by RFC 1521
and allows a character set to be specified.
Variant of
BeanDeserializer used for handling deserialization
of POJOs when serialized as JSON Arrays, instead of JSON Objects.Specialized POJO serializer that differs from
BeanSerializer
in that instead of producing a JSON Object it will output
a JSON Array, omitting field names, and serializing values in
specified serialization order.Basic container for information gathered by
ClassIntrospector to
help in constructing serializers and deserializers.Deserializer class that can deserialize instances of
arbitrary bean objects, usually from JSON Object structs,
Base class for
BeanDeserializer.Builder class used for aggregating deserialization information about
a POJO, in order to build a
JsonDeserializer for deserializing
instances.Concrete deserializer factory class that adds full Bean deserializer
construction logic using class introspection.
Abstract class that defines API for objects that can be registered
to participate in constructing
JsonDeserializer instances
(via DeserializerFactory).Bean properties are logical entities that represent data
that Java objects (POJOs (Plain Old Java Objects), sometimes also called "beans")
contain; and that are accessed using accessors (methods like getters
and setters, fields, constructor parameters).
Alternative "Null" implementation that can be used in cases where a non-null
BeanProperty is neededSimple stand-alone implementation, useful as a placeholder
or base class for more complex implementations.
Simple value classes that contain definitions of properties,
used during introspection of properties to use for
serialization and deserialization purposes.
Deprecated.
Since 2.3: use
PropertyFilter instead.Helper class used for storing mapping from property name to
SettableBeanProperty instances.Base bean property handler class, which implements common parts of
reflection-based functionality for accessing a property value and serializing
it.
Serializer class that can serialize Java objects that map
to JSON Object output.
Base class both for the standard bean serializer, and couple
of variants that only differ in small details.
Builder class used for aggregating deserialization information about
a POJO, in order to build a
JsonSerializer for serializing
intances.Factory class that can provide serializers for any regular Java beans
(as defined by "having at least one get method recognizable as bean
accessor" -- where
Object.getClass() does not count);
as well as for "standard" JDK types.Abstract class that defines API for objects that can be registered (for
BeanSerializerFactory
to participate in constructing BeanSerializer instances.Helper class that contains functionality needed by both serialization
and deserialization side.
Encodes strings into their Beider-Morse phonetic encoding.
Benchmark worker that can execute an HTTP method given number of times
Helper class used to implement more optimized parsing of
BigDecimal for REALLY
big values (over 500 characters)Numeric node that contains simple 64-bit integer values.
Converts between byte arrays and strings of "0"s and "1"s.
Defines common decoding methods for byte array decoders.
Defines common encoding methods for byte array encoders.
Value node that contains Base64 encoded binary value, which will be
output and stored as Json String value.
Supports operations on bit-mapped fields.
BlindSSLSocketFactoryTest
Simple test to show an Active Directory (LDAP)
and HTTPS connection without verifying the
server's certificate.
Specialized executor to get a boolean property from an object.
This concrete value class is used to contain boolean (true / false)
values.
Serializer used for primitive boolean, as well as java.util.Boolean
wrapper type.
Operations on boolean primitives and Boolean objects.
This is a small utility class, whose main functionality is to allow
simple reuse of raw byte/char buffers.
Helper entity used to control access to simple buffer recyling scheme used for
some encoding, decoding tasks.
The Builder interface is designed to designate a class as a builder
object in the Builder design pattern.
Class that handles deserialization using a separate
Builder class, which is used for data binding and
produces actual deserialized value at the end
of data binding.
Helper class that is similar to
ByteArrayOutputStream
in usage, but more geared to Jackson use cases internally.NonBlockingInputFeeder implementation used when feeding data
as byte arrays.A PartSource that reads from a byte array.
A RequestEntity that contains an array of bytes.
Unlike other integral number array serializers, we do not just print out byte values
as numbers.
Simple
InputStream implementation that exposes currently
available content of a ByteBuffer.Simple
OutputStream implementation that appends content
written in given ByteBuffer instance.NonBlockingInputFeeder implementation used when feeding data
as ByteBuffer contents.Replacement for
BytesToNameCanonicalizer which aims at more localized
memory access due to flattening of name quad data.This class is used to determine the encoding of byte stream
that is to contain JSON content.
Standard serializer for
Calendar.Helps use
Calendars.
A specialized
BackgroundInitializer implementation that wraps a
Callable object.Deprecated.
1.5 Replaced by
Caverphone2, will be removed in 2.0.Encodes a string into a Caverphone 1.0 value.
Encodes a string into a Caverphone 2.0 value.
Abstract base class that defines interface for customizing character
escaping aspects for String values, for formats that use escaping.
Character encoding names required of every implementation of the Java platform.
Deprecated.
Java 7 introduced
StandardCharsets, which defines these constants as
Charset objects.Deprecated.
as of 3.6, use commons-text
CharSequenceTranslator instead
Operations on
CharSequence that are null safe.Operations on
CharSequence that are
null safe.A set of characters.
Charsets required of every implementation of the Java platform.
Operations on
CharSet instances.This class is a kind of specialized type-safe Map, from char array to
String value.
Operations on char primitives and Character objects.
Transparently coalesces chunks of a HTTP stream that uses
Transfer-Encoding chunked.
Implements HTTP chunking support.
An interface describing a Circuit Breaker component.
An exception class used for reporting runtime error conditions related to
circuit breakers.
Signals a circular redirect
Helper class used to introspect features of POJO value classes
used with Jackson.
Interface used for decoupling details of how mix-in annotation
definitions are accessed (via this interface), and how
they are stored (defined by classes that implement the interface)
Key class, used as an efficient and accurate key
for locating per-class values, such as
JsonSerializers.Helps work with
ClassLoader.TypeIdResolver implementation
that converts between fully-qualified
Java class names and (JSON) Strings.Operations regarding the classpath.
Also: default bean access will not do much good with Class.class.
Simple helper class used to keep track of 'call stack' for classes being referenced
(as well as unbound variables)
Value class used for caching Constructor declarations; used because
caching done by JDK appears to be somewhat inefficient for some use cases.
Operates on classes without using reflection.
Inclusivity literals for
ClassUtils.hierarchy(Class, Interfaces).an operation of the grouper client
Exception thrown when a clone cannot be created.
Defines encoding and decoding policies.
Deprecated.
as of 3.6, use commons-text
CharSequenceTranslator instead
Set of possible actions for requested coercion from an
input shape
CoercionInputShape
that does not directly or naturally match target type
(LogicalType).Set of input types (which mostly match one of
JsonToken types) used for
configuring CoercionActions to take when reading
input into target types (specific type or LogicalType).Basic serializer that can take JSON "Array" structure and
construct a
Collection instance, with typed contents.Helper class for dealing with Object Id references for values contained in
collections being deserialized.
Type that represents things that act similar to
Collection;
but may or may not be instances of that interface.Fallback serializer for cases where Collection is not known to be
of type for which more specializer serializer exists (such as
index-accessible List).
Type that represents Java Collection types (Lists, Sets).
Encodes a string into a Cologne Phonetic value.
Utility library to provide helper methods for translating
Comparable.compareTo(T) result into a boolean.Provides access to the available methods
Assists in implementing
Comparable.compareTo(Object) methods.Deprecated.
as of 3.6, use commons-text
CompositeFormat instead
Definition of an interface for a wrapper around a calculation that takes a single parameter and returns a result.
Intermediate
BeanProperty class shared by concrete readable- and
writable property implementations for sharing common functionality.
An exception class used for reporting error conditions related to accessing
data of background tasks.
Definition of an interface for the thread-safe initialization of objects.
An exception class used for reporting runtime error conditions related to
accessing data of background tasks.
An utility class providing functionality related to the
java.util.concurrent package.logic to cache and retrieve the grouper config from the DB
note: do not use any Grouper classes in this class.
Interface that actual SerializationFeature enumerations used by
MapperConfig implementations must implement.Configuration object that is accessed by databinding functionality
to find overrides to configuration of properties, based on declared
type of the property.
Container for individual
ConfigOverride values.Base class for a cascaded config.
config file type
utility methods for grouper.
The results of executing a command.
utility methods specific to grouper client
A timeout while connecting waiting for an available connection
from an HttpConnectionManager.
Establishes a tunneled HTTP connection via the CONNECT method.
A timeout while connecting to an HTTP server or waiting for an
available connection from an HttpConnectionManager.
A very simple implementation of the
ConcurrentInitializer interface
which always returns the same object.Configurable handler used to select aspects of selecting
constructor to use as "Creator" for POJOs.
Definition of alternate handling modes of single-argument constructors
that are annotated with
JsonCreator
but without "mode" definition (or explicit name for the argument):
this is the case where two interpretations
are possible -- "properties" (in which case the argument is named parameter
of a JSON Object) and "delegating (in which case the argument maps to the
whole JSON value). Utility reflection methods focused on constructors, modeled after
MethodUtils.Intermediate base deserializer class that adds more shared accessor
so that other classes can access information about contained (value) types
This intermediate base class is used for all container nodes,
specifically, array and object nodes.
Intermediate base class for serializers used for serializing
types that contain element(s) of other types, such as arrays,
Collections (Lists, Sets
etc) and Maps and iterable things
(Iterators).Cuts the wrapped InputStream off after a specified number of bytes.
Abstraction that encloses information about content being processed --
input source or output target, streaming or
not -- for the purpose of including pertinent information in
location (see
JsonLocation)
objections, most commonly to be printed out as part of Exception
messages.This class provides mappings from file name extensions to content types.
A simple extension to
FilePart that automatically determines the content type
of the file.Helper class used for storing and accessing per-call attributes.
An exception that provides an easy and safe way to add contextual information.
A runtime exception that provides an easy and safe way to add contextual information.
Add-on interface that
JsonDeserializers can implement to get a callback
that can be used to create contextual (context-dependent) instances of
deserializer to use for handling properties of supported type.Add-on interface that
KeyDeserializers can implement to get a callback
that can be used to create contextual instances of key deserializer to use for
handling Map keys of supported type.Add-on interface that
JsonSerializers can implement to get a callback
that can be used to create contextual instances of serializer to use for
handling properties of supported type.This helper class is intedned to help work around the limitation of older Java versions
(older than 1.4) that prevents from specifying a connection timeout when creating a
socket.
Helper class for wrapping socket based tasks.
Static methods to convert a type into another, with endianness and bit ordering awareness.
Helper interface for things that convert Objects of
one type to another.
This marker class is only to be used with annotations, to
indicate that no converter is to be used.
HTTP "magic-cookie" represents a piece of state information
that the HTTP agent and the target server can exchange to maintain
a session.
Cookie class for
RFC2965Spec
cookie specification.Ths interface represents a cookie attribute handler responsible
for parsing, validating, and matching a specific cookie attribute,
such as path, domain, port, etc.
CookieOrigin class incapsulates details of an origin server that
are relevant when parsing, validating or matching HTTP cookies.
This cookie comparator ensures that multiple cookies satisfying
a common criteria are ordered in the Cookie header such
that those with more specific Path attributes precede those with
less specific.
Cookie management policy class.
Defines the cookie management specification.
Cookie management functions shared by all specification.
Defines cookie specification specific capabilities
Container deserializers that handle "core" XML types: ones included in standard
JDK 1.5.
Combo-deserializer that supports deserialization of somewhat optional
javax.xml types
QName, Duration and XMLGregorianCalendar.Provider for serializers of XML types that are part of full JDK 1.5, but
that some alleged 1.5 platforms are missing (Android, GAE).
Container class for storing information on creators (based on annotations,
visibility), to be able to build actual
ValueInstantiator later on.This concrete sub-class implements property that is passed
via Creator (constructor or static factory method).
Authentication credentials.
Authentication credentials required to respond to a authentication
challenge are not available
Credentials provider interface can be used to provide
HTTP method with a means to request
authentication credentials if no credentials have been given or given
credentials are incorrect.GNU libc crypt(3) compatible hash method.
Deprecated.
use edu.internet2.middleware.morphString.Crypto instead!
The purpose of this class is to provide encryption
and decryption using standard Java libraries, for potentially
large amounts of data.
A simple custom AuthScheme example.
Encodes a string into a Daitch-Mokotoff Soundex value.
Shared base class for
DeserializationContext and
SerializerProvider, context objects passed through data-binding
process.Intermediate base class for all databind level processing problems, as
distinct from stream-level problems or I/O issues below.
Simple helper class that allows data format (content type) auto-detection,
given an ordered set of
JsonFactory instances to use for actual low-level
detection.Result object constructed by
DataFormatDetector when requested
to detect format of given input data.Alternative to
DataFormatDetector that needs to be used when
using data-binding.We need sub-class here as well, to be able to access efficiently.
Result class, similar to
DataFormatMatcherHelper class to support use of
DataOutput for output, directly,
without caller having to provide for implementation.Interface that defines interaction with data type specific configuration
features.
Immutable value class that contains settings for multiple
DatatypeFeature enumerations.Container class for core JDK date/time type deserializers.
Simple deserializer for handling
Date values.Compared to plain old
Date, SQL version is easier
to deal with: mostly because it is more limited.Simple deserializer for handling
Timestamp values.Date and time formatting utilities and constants.
An exception to indicate an error parsing a date string.
Deprecated.
Use
DateUtilDateParser is the "missing" interface for the parsing methods of
DateFormat.DatePrinter is the "missing" interface for the format methods of
DateFormat.For efficiency, we will serialize Dates as longs, instead of
potentially more readable Strings.
A utility class for parsing and formatting HTTP dates as used in cookies and
other headers.
Helper class to carry in info such as a url/file name, line and column for
debugging information reporting.
Numeric node that contains values that do not fit in simple
integer (int, long) or floating point (double) values.
Provides the highest level of abstraction for Decoders.
Thrown when there is a failure condition during the decoding process.
Default
AccessorNamingStrategy used by Jackson: to be used either as-is,
or as base-class with overrides.Definition of a handler API to use for checking whether given base name
(remainder of accessor method name after removing prefix) is acceptable
based on various rules.
Simple implementation of
DefaultAccessorNamingStrategy.BaseNameValidator that checks the
first character and nothing else.Provider for
DefaultAccessorNamingStrategy.Implementation used for supporting "non-prefix" naming convention of
Java 14
java.lang.Record types, and in particular find default
accessors for declared record fields.PolymorphicTypeValidator that will only allow polymorphic handling if
the base type is NOT one of potential dangerous base types (see DefaultBaseTypeLimitingValidator.isUnsafeBaseType(edu.internet2.middleware.grouperClientExt.com.fasterxml.jackson.databind.cfg.MapperConfig<?>, edu.internet2.middleware.grouperClientExt.com.fasterxml.jackson.databind.JavaType)
for specific list of such base types).Complete
DeserializationContext implementation that adds
extended API for ObjectMapper (and ObjectReader)
to call, as well as implements certain parts that base class
has left abstract.Actual full concrete implementation
Default implementation of the context storing the label-value pairs for contexted exceptions.
The default
HttpMethodRetryHandler used by HttpMethods.This class represents a collection of HTTP protocol parameters.
Default linefeed-based indenter, used by
DefaultPrettyPrinter (unless
overridden).Deprecated.
Default
PrettyPrinter implementation that uses 2-space
indentation with platform-default linefeeds.This is a very simple indenter that only adds a
single space for indentation.
Interface that defines objects that can produce indentation used
to separate object entries and array values.
Dummy implementation that adds no indentation whatsoever
The default class for creating protocol sockets.
Standard implementation used by
ObjectMapper:
adds methods only exposed to ObjectMapper,
as well as constructors.Concrete implementation that defines factory method(s),
defined as final.
Base class that simplifies implementations of
JsonDeserializers
that mostly delegate functionality to another deserializer implementation
(possibly forming a chaing of deserializers delegating functionality
in some cases)Implements the HTTP DELETE method.
Object that contains baseline configuration for deserialization
process.
Context for the process of deserialization a single root-level value.
Enumeration that defines simple on/off features that affect
the way Java objects are deserialized from JSON
This is the class that can be registered (via
DeserializationConfig object owner by
ObjectMapper) to get called when a potentially
recoverable problem is encountered during deserialization
process.Class that defines caching layer between callers (like
ObjectMapper,
DeserializationContext)
and classes that construct deserializers
(DeserializerFactory).Abstract class that defines API used by
DeserializationContext
to construct actual
JsonDeserializer instances (which are then cached by
context and/or dedicated cache).Configuration settings container class for
DeserializerFactory.Interface that defines API for simple extensions that can provide additional deserializers
for various types.
Basic
Deserializers implementation that implements all methods but provides
no deserializers.
A
Diff contains the differences between two Diffable class
fields.Diffable classes can be compared with other objects
for differences.
Assists in implementing
Diffable.diff(Object) methods.
A
DiffResult contains a collection of the differences between two
Diffable objects.A minimal command line to run digest over files, directories or a string
Digest authentication scheme as defined in RFC 2617.
Operations to simplify common
MessageDigest tasks.This client will manage discovery, cache results, etc
TODO add checksum
Base for serializers that allows parsing DOM Documents from JSON Strings.
Encodes a string into a double metaphone value.
Numeric node that contains 64-bit ("double precision")
floating point values simple 32-bit integer values.
This class exposes a method to render a
double as a string.Specialized executor to get a property from an object.
Specialized executor to set a property of an object.
Helper class used if
JsonParser.Feature.STRICT_DUPLICATE_DETECTION
is enabled.Duration formatting utilities and constants.
Utilities for
Duration.
EasySSLProtocolSocketFactory can be used to creats SSL
Sockets
that accept self-signed certificates.Apache code for SSL that doesnt fail with self-signed certs
jakarta code for SSL that doesnt fail with self-signed certs
EasyX509TrustManager unlike default
X509TrustManager accepts
self-signed certificates.Provides the highest level of abstraction for Encoders.
Thrown when there is a failure condition during the encoding process.
The home for utility methods that handle various encoding tasks.
Deprecated.
use edu.internet2.middleware.morphString.Encrypt instead!
from sh or bat file to encrypt a string
Deprecated.
as of 3.6, use commons-text
EntityArrays instead
This abstract class serves as a foundation for all HTTP methods
that can enclose an entity within requests
Deserializer class that can deserialize instances of
specified Enum class from Strings and Integers.
An Iterator wrapper for an Enumeration.
New Datatype-specific configuration options related to handling of
Enum types.Deserializer for
EnumMap values.Helper class used to resolve String values (either JSON Object field
names or regular String values) into Java Enum instances.
Standard serializer used for
Enum types.Standard deserializer for
EnumSets.Utility library to provide helper methods for Java enums.
Helper class used for storing String serializations of
Enums,
to match to/from external representations.Assists in implementing
Object.equals(Object) methods.Use this annotation to exclude a field from being used by
the various
reflectionEquals methods defined on
EqualsBuilder.A deserializer that stores an
Error caught during constructing
of the deserializer, which needs to be deferred and only during actual
attempt to deserialize a value of given type.
A simple implementation of the Circuit Breaker pattern
that counts specific events.
An EventListenerSupport object can be used to manage a list of event
listeners of a particular type.
Provides some useful event-based utility methods.
Allows the storage and retrieval of contextual information based on label-value
pairs for exceptions.
The home for utility methods that handle various exception-related tasks.
Provides utilities for manipulating and examining
Throwable objects.
This abstract class serves as a foundation for all HTTP methods
that support 'Expect: 100-continue' handshake.
This is like a map, but the setters also take an expire time which
will mean the items in the cache will be automatically deleted.
unit of time for expirable cache
This holds the actual value of the map, and the time it was inserted, and
the time that it should last in the cache
Represents a single JEXL expression.
Instances of ExpressionImpl are created by the
JexlEngine,
and this is the default implementation of the Expression and
Script interface.Deprecated.
as of 3.6, use commons-text
ExtendedMessageFormat instead
Helper class that is used to flatten JSON structure when using
"external type id" (see
JsonTypeInfo.As.EXTERNAL_PROPERTY).This class provides utility functions, and classes for working with the
java.util.function package, or more
generally, with Java 8 lambdas.A functional interface like
BiConsumer that declares a Throwable.A functional interface like
BiFunction that declares a Throwable.A functional interface like
BiPredicate that declares a Throwable.A functional interface like
BooleanSupplier that declares a Throwable.A functional interface like
Callable that declares a Throwable.A functional interface like
Consumer that declares a Throwable.A functional interface like
DoubleBinaryOperator that declares a Throwable.A functional interface like
DoubleConsumer that declares a Throwable.A functional interface like
DoubleFunction that declares a Throwable.A functional interface like
DoublePredicate that declares a Throwable.A functional interface like
DoubleSupplier that declares a Throwable.A functional interface like
DoubleToIntFunction that declares a Throwable.A functional interface like
DoubleToLongFunction that declares a Throwable.A functional interface like
DoubleUnaryOperator that declares a Throwable.A functional interface like
Function that declares a Throwable.A functional interface like
IntBinaryOperator that declares a Throwable.A functional interface like
IntConsumer that declares a Throwable.A functional interface like
IntFunction that declares a Throwable.A functional interface like
IntPredicate that declares a Throwable.A functional interface like
IntSupplier that declares a Throwable.A functional interface like
IntToDoubleFunction that declares a Throwable.A functional interface like
IntToLongFunction that declares a Throwable.A functional interface like
IntUnaryOperator that declares a Throwable.A functional interface like
LongBinaryOperator that declares a Throwable.A functional interface like
LongConsumer that declares a Throwable.A functional interface like
LongFunction that declares a Throwable.A functional interface like
LongPredicate that declares a Throwable.A functional interface like
LongSupplier that declares a Throwable.A functional interface like
LongToDoubleFunction that declares a Throwable.A functional interface like
LongToIntFunction that declares a Throwable.A functional interface like
LongUnaryOperator that declares a Throwable.A functional interface like
ObjDoubleConsumer that declares a Throwable.A functional interface like
ObjIntConsumer that declares a Throwable.A functional interface like
ObjLongConsumer that declares a Throwable.A functional interface like
Predicate that declares a Throwable.A functional interface like
Runnable that declares a Throwable.A functional interface like
Supplier that declares a Throwable.A functional interface like
ToDoubleBiFunction that declares a Throwable.A functional interface like
ToDoubleFunction that declares a Throwable.A functional interface like
ToIntBiFunction that declares a Throwable.A functional interface like
ToIntFunction that declares a Throwable.A functional interface like
ToLongBiFunction that declares a Throwable.A functional interface like
ToLongFunction that declares a Throwable.Special bogus "serializer" that will throw
MismatchedInputException if an attempt is made to deserialize
a value.Special bogus "serializer" that will throw
JsonMappingException if its FailingSerializer.serialize(java.lang.Object, edu.internet2.middleware.grouperClientExt.com.fasterxml.jackson.core.JsonGenerator, edu.internet2.middleware.grouperClientExt.com.fasterxml.jackson.databind.SerializerProvider)
gets invoked.logic for hitting multiple resources checking for errors and timeouts for always availability.
configuration of a failover connection type
failover strategy to employ with each pool type
Logic to run.
bean in callback for failover logic
FastDateFormat is a fast and thread-safe version of
SimpleDateFormat.FastDateParser is a fast and thread-safe version of
SimpleDateFormat.FastDatePrinter is a fast and thread-safe version of
SimpleDateFormat.Faster methods to produce custom time zones.
This concrete sub-class implements property that is set
directly assigning to a Field.
Utilities for working with
Fields by reflection.This class implements a part of a Multipart post object that
consists of a file.
A PartSource that reads from a File.
A RequestEntity that represents a File.
For now, File objects get serialized by just outputting
absolute (but not canonical) name as String value
Decorated
BeanPropertyWriter that will filter out properties
that are not to be included in currently active JsonView.Specialized
JsonGeneratorDelegate that allows use of
TokenFilter for outputting a subset of content that
caller tries to generate.Specialized
JsonParserDelegate that allows use of
TokenFilter for outputting a subset of content that
is visible to callerInterface for objects that providers instances of
PropertyFilter
that match given ids.JsonNode implementation for efficiently containing 32-bit
`float` values.This class exposes a method to render a
float as a string.Deprecated.
as of 3.6, use commons-text
FormatFactory instead
Marker interface that is to be implemented by data format - specific features.
Simple tag interface used to mark schema objects that are used by some
JsonParser and JsonGenerator implementations to further
specify structure of expected format.Deprecated.
as of 3.6, use commons-text
FormattableUtils instead
Fraction is a Number implementation that
stores fractions accurately.Base class for simple deserializers that serialize values from String
representation: this includes JSON Strings and other Scalar values that
can be coerced into text, like Numbers and Booleans).
"Chameleon" deserializer that works on simple types that are deserialized
from a simple String.
Deprecated.
Use
Failable.Deprecated.
Use
FailableBiConsumer.Deprecated.
Use
FailableBiFunction.Deprecated.
Use
FailableBiPredicate.Deprecated.
Use
FailableCallable.Deprecated.
Use
FailableConsumer.Deprecated.
Use
FailableFunction.Deprecated.
Use
FailablePredicate.Deprecated.
Use
FailableRunnable.Deprecated.
Use
FailableSupplier.class to run an add member web service call
class to assign actions to attribute def
class to assign an attributeDefName inheritance web service call
class to run an assign attributes web service call
class to run an assign attributes web service call
class to run a assign grouper privileges web service call
class to run a assign grouper privileges web service call
class to run an assign permissions web service call
class to run an attributeDef delete web service call
class to run an attributeDefName delete web service call
class to run an attributeDefName save web service call
class to run an attributeDef save web service call
This is our helper to convert data to and from Oracle.
This is our implementation of a helper to convert data to and from Oracle.
Object that gets a callableStatement back from the connection and the sql - closing it is handled within the framework.
Map with string key which ignores key case and has some convenience methods.
Object that gets a database connection object.
Use this class to get access to the global database connections, create a new connection,
and execute sql against them.
returned from connection call
Map for caching some query results for x amount of time.
class to run an delete member web service call
utility methods for grouper that are safe to use in expression language.
encryption
Object that gets a call for each entity created from a resultset; save heap space.
class to run a external subject delete web service call
class to run a external subject save web service call
class to run find attributeDefNames
class to run find attributeDefs
class to run find external subject
class to run find groups
class to run find stems
class to run a get attribute assign actions web service call
class to run a get attribute assignments web service call
class to run a get audit entries web service call
class to run a get grouper privileges web service call
class to run a get groups web service call
class to run a get members web service call
class to run a get memberships web service call
class to run a get permission assignments web service call
class to run a get subjects web service call
class to run a group delete web service call
one record for each provisioner.
dao for jobs
data about groups being synced
heartbeat and other logic for sync jobs
Status of all jobs for the sync.
dao for jobs
last log for this sync that affected this group/member/membership/job
if doing user level syncs, this is the metadata
if doing user level syncs, this is the metadata
membership dao
class to run a group save web service call
class to run a has member web service call
bean that wraps connections
gives connections and allows returns.
indent json, assumes the input is not yet indented.
Generate an ldap call and get results.
represents the configuration of an ldap search attribute
type of result in the ldap search attribute
class to run a member change subject
Whether fields should be persisted to the database or not.
Metadata about class objects that can be stored to the database.
Metadata about fields that can be stored to the database.
Object that gets a preparedStatement back from the connection and the sql - closing it is handled within the framework.
Structure to encapsulate data about a query being executed.
Object that gets a resulset via callback.
implement this interface to assign a new primary key for insert
class to run a stem delete service call
class to run a stem save web service call
AES/ECB/PKCS5Padding
sync a table
an instance of this class focuses on the configuration for table sync
create an instance, set the key, and call configure
Sync to a table from a dataset, columns, etc
table sync log
data from a row
type of table sync
info about the table.
data from a table
metadata for connection name and table name
Object that gets a dbAccess object with a session in it.
Possible endings for a transaction.
enum of possible transaction types
exception thrown if non success with web service
This base class implements part of API that a JSON generator exposes
to applications, adds shared internal methods that sub-classes
can use and adds some abstract methods sub-classes must implement.
Implements the HTTP GET method.
main class for grouper client.
utility methods for grouper.
The results of executing a command.
hierarchical config class for grouper.client.properties
client threadlocal state
utility methods specific to grouper client
dont print null fields in reflection
this is the client that all requests go through.
grouper client ws exception
grouper message sent to/from grouper messaging systems
param to mark a message as processed or return to queue or whatever
this is what you can do when acknowledging a message
grouper message sent to/from grouper messaging systems
method chaining receive message config
type of queues
method chaining receive message config
result bean to receive messages
param for sending a message
result of send
method chaining system config
configs in grouper.client.properties
# name of a messaging system.
engine sends, receives, marks messages complete
Represents the methods that a messaging system
needs to support
Helper class used for handling details of creating handler instances (things
like
JsonSerializers, JsonDeserializers, various type
handlers) of specific types.
Assists in implementing
Object.hashCode() methods.Use this annotation to exclude a field from being used by
the various
reflectionHashcode methods defined on
HashCodeBuilder.An HTTP header.
One element of an HTTP header's value.
A class for combining a set of headers.
Implements the HTTP HEAD method.
Converts hexadecimal Strings.
Standard
HmacUtils algorithm names from the Java Cryptography Architecture Standard Algorithm Name
Documentation.Simplifies common
Mac tasks.Holds all of the variables needed to describe an HTTP connection to a host.
A kind of HostConfiguration that can retain its Protocol when its host name
or port changes.
This class represents a collection of HTTP protocol parameters applicable to
instances of HostConfiguration.Deprecated.
no longer used
Deprecated.
no longer used
response from http call
An HTTP "user-agent", containing an
HTTP state and
one or more HTTP connections, to which
HTTP methods can be applied.Signals that an error has occurred.
This class represents a collection of HTTP protocol parameters applicable to
instances of HttpClient.An abstraction of an HTTP
InputStream and OutputStream
pair, together with the relevant attributes.An interface for classes that manage HttpConnections.
This class represents a collection of HTTP protocol parameters applicable to
HTTP connection managers.This class represents a collection of HTTP protocol parameters applicable to
HTTP connections.Deprecated.
use EncodingUtil class
Signals that the response content was larger than anticipated.
Signals that an HTTP or HttpClient exception has occurred.
Holds all of the variables needed to describe an HTTP connection to a host.
A source of HttpHosts.
HttpMethod interface represents a request to be sent via a
HTTP connection and a corresponding response.An abstract base implementation of HttpMethod.
Deprecated.
DISCLAIMER: HttpClient developers DO NOT actively support this component.
This class represents a collection of HTTP protocol parameters applicable to
HTTP methods.A handler for determining if an HttpMethod should be retried after a
recoverable exception during execution.
This interface represents a collection of HTTP protocol parameters.
A factory for getting the default set of parameters to use when creating an instance of
HttpParams.A utility class for parsing http header values according to
RFC-2616 Section 4 and 19.3.
Deprecated.
no longer used
A container for HTTP attributes that may persist from request
to request, such as
cookies and authentication
credentials.Constants enumerating the HTTP status codes.
The HTTPS URL.
The HTTP URL.
Provides a
HttpURLConnection wrapper around HttpClient's
HttpMethod.HTTP version, as specified in RFC 2616.
A helper class for connection managers to track idle connections.
A utility class for periodically closing idle connections.
Provides IEEE-754r variants of NumberUtils methods.
A cookie spec that does nothing.
Specialized
JsonMappingException sub-class used to indicate
case where an explicitly ignored property is encountered, and mapper
is configured to consider this an error.Helper class to encapsulate logic from static
shouldIgnore method
of util class.An immutable pair consisting of two
Object elements.An immutable triple consisting of three
Object elements.This is an optimized serializer for Lists that can be efficiently
traversed by index (as opposed to others, such as
LinkedList
that cannot}.Efficient implement for serializing
Lists that contains Strings and are random-accessible.Simple serializer for
InetAddress.Simple serializer for
InetSocketAddress.Utility methods focusing on inheritance.
Abstract class that defines API for objects that provide value to
"inject" during deserialization.
Simple standard implementation which uses a simple Map to
store values to inject, identified by simple String keys.
This sub-class is used to handle special case of value being a
non-static inner class.
Interface used to expose beginning of a data file to data format
detection code.
Basic implementation that reads data from given
InputStream and buffers it as necessary.Exception type for read-side problems that are not direct decoding ("parsing")
problems (those would be reported as
JsonParseExceptions),
but rather result from failed attempts to convert specific Java value out of valid
but incompatible input value.Handler class that can be used to decorate input sources.
A RequestEntity that contains an InputStream.
Add-on interface used to indicate things that may be "blueprint" objects
which can not be used as is, but are used for creating usable per-process
(serialization, deserialization) instances, using
Instantiatable.createInstance() method.Singleton class that adds a simple first-level cache in front of
regular String.intern() functionality.
An interpreter of JEXL syntax.
Numeric node that contains simple 32-bit integer values.
Default introspection services.
This basic function of this class is to return a Method object for a
particular class given the name of a method and the parameters to the method
in the form of an Object[]
Authentication credentials required to respond to a authentication
challenge are invalid
Intermediate exception type used as the base class for all
JsonMappingExceptions
that are due to problems with target type definition; usually a problem with
annotations used on a class or its properties.Specialized sub-class of
MismatchedInputException
that is used when the underlying problem appears to be that
of bad formatting of a value to deserialize.Exception thrown if a `null` value is being encountered for a property
designed as "fail on null" property (see
JsonSetter).Signals violation of HTTP specification caused by an invalid redirect
location
Exception thrown when resolution of a type id fails.
To limit number of configuration and state objects to pass, all
contextual objects that need to be passed by the factory to
readers and writers are combined under this object.
Deprecated.
Use
StdDateFormat insteadDeprecated.
Meta-annotation (annotations used on other annotations)
used for marking all annotations that are
part of Jackson package.
AnnotationIntrospector implementation that handles standard
Jackson annotations.Meta-annotation (annotations used on other annotations)
used for indicating that instead of using target annotation
(annotation annotated with this annotation),
Jackson should use meta-annotations it has.
Marker interface used by value classes like
JsonFormat.Value that are used
to contain information from one of Jackson annotations, and can be directly
instantiated from those annotations, as well as programmatically constructed
and possibly merged.Base class for all Jackson-produced checked exceptions.
Basic API implemented by Enums used for simple Jackson "features": on/off
settings and capabilities exposed as something that can be internally
represented as bit sets.
Container similar to
EnumSet meant for storing sets of
JacksonFeatures (usually Enums): main
difference being that these sets are immutable.Jackson-specific annotation used for indicating that value of
annotated property will be "injected", i.e.
Helper class used to contain information from a single
JacksonInject
annotation, as well as to provide possible overrides from non-annotation sources.Marker interface used to indicate implementation classes
(serializers, deserializers etc) that are standard ones Jackson
uses; not custom ones that application has added.
To support Java7-incomplete platforms, we will offer support for JDK 7
datatype(s) (that is,
Path through this class, loaded
dynamically; if loading fails, support will be missing.To support Java7-incomplete platforms, we will offer support for JDK 7
annotations through this class, loaded dynamically; if loading fails,
support will be missing.
Base class for type token classes used both to contain information
and as keys for deserializers.
Deprecated.
as of 3.6, use commons-text
UnicodeEscaper instead
Helper class used to contain logic for deserializing "special" containers
from
java.util.Collections and java.util.Arrays.An enum representing all the versions of the Java specification.
Implementation of the
org.apache.commons.logging.Log
interface that wraps the standard JDK logging mechanisms that are
available in SourceForge's Lumberjack for JDKs prior to 1.4.Implementation of the
org.apache.commons.logging.Log
interface that wraps the standard JDK logging mechanisms that were
introduced in the Merlin release (JDK 1.4).Helper class to support some of JDK 14 (and later) features
without Jackson itself being run on (or even built with) Java 14.
Container class that contains serializers for JDK types that
require special handling for some reason.
Container for a set of
ValueInstantiators used for certain critical
JDK value types, either as performance optimization for initialization time observed
by profiling, or due to difficulty in otherwise finding constructors.Perform arithmetic.
Manages variables which can be referenced in a JEXL expression.
Creates and evaluates Expression and Script objects.
A call frame, created from a scope, stores the arguments and local variables as "registers".
A script scope, stores the declaration of parameters and local variables.
Wraps any error that might occur during interpretation of a script or expression.
Thrown to cancel a script execution.
Thrown when a method or ctor is unknown, ambiguous or inaccessible.
Thrown when parsing fails.
Thrown when a property is unknown.
Thrown to return a value.
Thrown when tokenization fails.
Thrown when a variable is unknown.
Interface for objects carrying information usefull to debugging.
Interface used for regular method invocation.
Base class for parser nodes - holds an 'image' of the token for later use.
A marker interface for literals.
The base class for parsing, manages the parameter/local variable frame.
Interface for getting values that appear to be properties.
Interface used for setting values that appear to be properties.
Implements the Jexl ScriptEngine for JSF-223.
Implements the Jexl ScriptEngineFactory for JSF-223.
A derived arithmetic that allows different threads to operate with
different strict/lenient/math modes using the same JexlEngine.
Annotation that can be used to define one or more alternative names for
a property, accepted during deserialization as alternative to the official
name.
Default "empty" implementation, useful as the base to start on;
especially as it is guaranteed to implement all the method
of the interface, even if new methods are getting added.
Marker annotation that can be used to define a non-static,
no-argument method to be an "any getter"; accessor for getting
a set of key/value pairs, to be serialized as part of containing POJO
(similar to unwrapping) along with regular property values it has.
Marker annotation that can be used to define a logical "any setter" mutator --
either using non-static
two-argument method (first argument name of property, second value
to set) or a field (of type
Map or POJO) -
to be used as a "fallback" handler
for all otherwise unrecognized properties found from JSON content.Annotation that may be used to add "virtual" properties to be written
after regular properties (although ordering may be changed using
both standard
@JsonPropertyOrder annotation, and
properties of this annotation).Definition of a single attribute-backed property.
Definition of a single general virtual property.
Default "empty" implementation, useful as the base to start on;
especially as it is guaranteed to implement all the method
of the interface, even if new methods are getting added.
Class annotation that can be used to define which kinds of Methods
are to be detected by auto-detection, and with what minimum access level.
Helper class used to contain information from a single
JsonIgnoreProperties
annotation, as well as to provide possible overrides from non-annotation sources.Enumeration for possible visibility thresholds (minimum visibility)
that can be used to limit which methods (and fields) are
auto-detected.
Annotation used to indicate that associated property is part of
two-way linkage between fields; and that its role is "child" (or "back") link.
Default "empty" implementation, useful as the base to start on;
especially as it is guaranteed to implement all the method
of the interface, even if new methods are getting added.
Annotation used to define a human-readable description for annotated
type (class).
Marker annotation that can be used to define constructors and factory
methods as one to use for instantiating new instances of the associated
class.
Annotation use for configuring deserialization aspects, by attaching
to "setter" methods or fields, or to value classes.
Abstract class that defines API used by
ObjectMapper (and
other chained JsonDeserializers too) to deserialize Objects of
arbitrary types from JSON, using provided JsonParser.This marker class is only to be used with annotations, to
indicate that no deserializer is configured.
Enumeration that defines legal encodings that can be used
for JSON content, based on list of allowed encodings from
JSON specification.
Marker annotation that can be used to define a default value
used when trying to deserialize unknown Enum values.
Specialized
JsonParseException that is thrown when end-of-input
is reached unexpectedly, either within token being decoded, or during
skipping of intervening white-space that is not between root-level
tokens (that is, is within JSON Object or JSON Array construct).The main factory class of Jackson package, used to configure and
construct reader (aka parser,
JsonParser)
and writer (aka generator, JsonGenerator)
instances.Enumeration that defines all on/off features that can only be
changed for
JsonFactory.TSFBuilder
implementation for constructing vanilla JsonFactory
instances for reading/writing JSON encoded content.Annotation used to indicate which logical filter is to be used
for filtering out properties of type (class) annotated;
association made by this annotation declaring ids of filters,
and
edu.internet2.middleware.grouperClientExt.com.fasterxml.jackson.databind.ObjectMapper (or objects
it delegates to) providing matching filters by id.General-purpose annotation used for configuring details of how
values of properties are to be serialized.
Set of features that can be enabled/disabled for property annotated.
Value enumeration used for indicating preferred Shape; translates
loosely to JSON types, with some extra values to indicate less precise
choices (i.e.
Helper class used to contain information from a single
JsonFormat
annotation.Interface
JsonSerializer implements
to allow for visiting type hierarchy.Interface for visitor callbacks, when type in question can be any of
legal JSON types.
Empty "no-op" implementation of
JsonFormatVisitorWrapper, suitable for
sub-classing.Exception type for exceptions during JSON writing, such as trying
to output content in wrong context (non-matching end-array or end-object,
for example).
Base class that defines public API for writing JSON content.
Enumeration that defines all togglable features for generators.
Intermediate base class shared by JSON-backed generators
like
UTF8JsonGenerator and WriterBasedJsonGenerator.Marker annotation that can be used to define a non-static,
no-argument value-returning (non-void) method to be used as a "getter"
for a logical property.
Annotation used for indicating that values of annotated type
or property should be serializing so that instances either
contain additional object identifier (in addition actual object
properties), or as a reference that consists of an object id
that refers to a full serialization.
Optional annotation that can be used for customizing details of a reference
to Objects for which "Object Identity" is enabled (see
JsonIdentityInfo).Marker annotation that indicates that the logical property that
the accessor (field, getter/setter method or Creator parameter
[of
JsonCreator-annotated constructor or factory method])
is to be ignored by introspection-based
serialization and deserialization functionality.Annotation that can be used to either suppress serialization of
properties (during serialization), or ignore processing of
JSON properties read (during deserialization).
Helper class used to contain information from a single
JsonIgnoreProperties
annotation, as well as to provide possible overrides from non-annotation sources.Marker annotation that indicates that all properties that have
type annotated with this annotation
are to be ignored during serialization and deserialization.
Annotation used to indicate when value of the annotated property (when
used for a field, method or constructor parameter), or all
properties of the annotated class, is to be serialized.
Enumeration used with
JsonInclude
to define which properties
of Java Beans are to be included in serialization.Helper class used to contain information from a single
JsonInclude
annotation.Annotation that can be used to either only include serialization of
properties (during serialization), or only include processing of
JSON properties read (during deserialization).
Helper class used to contain information from a single
JsonIncludeProperties
annotation, as well as to provide possible overrides from non-annotation sources.indent json, assumes the input is not yet indented.
Default "empty" implementation, useful as the base to start on;
especially as it is guaranteed to implement all the method
of the interface, even if new methods are getting added.
Marker annotation
that indicates that the value of annotated accessor (either field
or "getter" method [a method with non-void return type, no args])
is to be used as the single value to serialize for the instance.
Object that encapsulates Location information used for reporting
parsing (or potentially generation) errors, as well as current location
within input streams.
For
JsonLocation, we should be able to just implement
ValueInstantiator (not that explicit one would be very
hard but...)Annotation used to indicate that annotated property is part of
two-way linkage between fields; and that its role is "parent" (or "forward") link.
Default "empty" implementation, useful as the base to start on;
especially as it is guaranteed to implement all the method
of the interface, even if new methods are getting added.
JSON-format specific
ObjectMapper implementation.Base implementation for "Vanilla"
ObjectMapper, used with
JSON dataformat backend.Checked exception used to signal fatal problems with mapping of
content, distinct from low-level I/O problems (signaled using
simple
IOExceptions) or data encoding/decoding
problems (signaled with StreamReadException,
StreamWriteException).Simple bean class used to contain references.
Annotation to specify whether annotated property value should use "merging" approach:
merging meaning that the current value is first accessed (with a getter or field) and then modified
with incoming data.
Annotation that can be used to indicate a
PropertyNamingStrategy
to use for annotated class.Base class for all JSON nodes, which form the basis of JSON
Tree Model that Jackson implements.
Configuration setting used with
JsonNode.withObject(JsonPointer)
method overrides, to indicate which overwrites are acceptable if the
path pointer indicates has incompatible nodes (for example, instead
of Object node a Null node is encountered).Interface that defines common "creator" functionality implemented
both by
JsonNodeFactory and ContainerNode (that is,
JSON Object and Array nodes).Base class that specifies methods for getting access to
Node instances (newly constructed, or shared, depending
on type), as well as basic implementation of the methods.
New Datatype-specific configuration options related to handling of
JsonNode types.Enumeration of JSON types.
Default "empty" implementation, useful as the base to start on;
especially as it is guaranteed to implement all the method
of the interface, even if new methods are getting added.
Default "empty" implementation, useful as the base to start on;
especially as it is guaranteed to implement all the method
of the interface, even if new methods are getting added.
Visitor called when properties of a type that maps to JSON Object
are being visited: this usually means POJOs, but sometimes other
types use it too (like
EnumMap).Default "empty" implementation, useful as the base to start on;
especially as it is guaranteed to implement all the method
of the interface, even if new methods are getting added.
Exception type for parsing problems, used when non-well-formed content
(content that does not conform to JSON syntax as per specification)
is encountered.
Base class that defines public API for reading JSON content.
Enumeration that defines all on/off features for parsers.
Enumeration of possible "native" (optimal) types that can be
used for numbers.
Helper class that implements
delegation pattern for
JsonParser,
to allow for simple overridability of basic parsing functionality.Helper class that can be used to sequence multiple physical
JsonParsers to create a single logical sequence of
tokens, as a single JsonParser.Convenience
CharacterEscapes implementation that escapes
Unicode characters `0x2028` and `0x2029` (in addition to characters
escaped otherwise), which are apparently considered linefeeds as
per newer Javascript specifications, and consequently problematic
when using JSONP (see https://en.wikipedia.org/wiki/JSONP).Container class that can be used to wrap any Object instances (including
nulls), and will serialize embedded in
JSONP wrapping.
Implementation of
JSON Pointer
specification.
Simple
TokenFilter implementation that takes a single
JsonPointer and matches a single value accordingly.Annotation used to configure details of a Builder class:
instances of which are used as Builders for deserialized
POJO values, instead of POJOs being instantiated using
constructors or factory methods.
Simple value container for containing values read from
JsonPOJOBuilder annotation instance.Intermediate base class for all problems encountered when
processing (parsing, generating) JSON content
that are not pure I/O problems.
Marker annotation that can be used to define a non-static
method as a "setter" or "getter" for a logical property
(depending on its signature),
or non-static object field to be used (serialized, deserialized) as
a logical property.
Various options for
JsonProperty.access() property, specifying how property
may be accessed during serialization ("read") and deserialization ("write")
(note that the direction of read and write is from perspective of the property,
not from external data format: this may be confusing in some contexts).Annotation used to define a human-readable description for a logical
property.
Annotation that can be used to define ordering (possibly partial) to use
when serializing object properties.
Marker annotation that indicates that the annotated method
or field should be serialized by including literal String value
of the property as is, without quoting of characters.
Extension of
JsonStreamContext, which implements
core methods needed, and also exposes
more complete API to parser implementation classes.Token reader (parser) features specific to JSON backend.
Annotation similar to
javax.xml.bind.annotation.XmlRootElement,
used to indicate name to use for root-level wrapping, if wrapping is
enabled.Deprecated.
Since 2.2, we recommend use of external
JSON Schema generator module
Interface that can be implemented by objects that know how to
serialize themselves to JSON, using
JsonGenerator
(and SerializerProvider if necessary).Base class with minimal implementation, as well as couple of extension methods
that core Jackson databinding makes use of.
Annotation that can be used to define JSON Schema definition for
the annotated class.
Annotation used for configuring serialization aspects, by attaching
to "getter" methods or fields, or to value classes.
Deprecated.
Enumeration used with
JsonSerialize.typing() property
to define whether type detection is based on dynamic runtime
type (DYNAMIC) or declared type (STATIC).Abstract class that defines API used by
ObjectMapper (and
other chained JsonSerializers too) to serialize Objects of
arbitrary types into JSON, using provided JsonGenerator.This marker class is only to be used with annotations, to
indicate that no serializer is configured.
Annotation that can be used to define a non-static,
single-argument method to be used as a "setter" for a logical property
as an alternative to recommended
JsonProperty annotation;
or (as of 2.9 and later), specify additional aspects of the
assigning property a value during serialization.Helper class used to contain information from a single
JsonSetter
annotation, as well as to provide possible overrides from non-annotation sources.Shared base class for streaming processing contexts used during
reading and writing of Json content using Streaming API.
Helper class used for efficient encoding of JSON String values (including
JSON field names) into Strings or UTF-8 byte arrays.
Default "empty" implementation, useful as the base to start on;
especially as it is guaranteed to implement all the method
of the interface, even if new methods are getting added.
Annotation used with
JsonTypeInfo to indicate subtypes of serializable
polymorphic types, and to associate logical names used within JSON content
(which is more portable than using physical Java class names).Definition of a subtype, along with optional name(s).
Enumeration for basic token types used for returning results
of parsing JSON content.
Interface defined to contain ids accessible with
JsonToken.id().Marker annotation that can be used on a property accessor
(field, getter or setter, constructor parameter) to indicate that
the property is to contain type id to use when including
polymorphic type information.
Annotation that can be used to plug a custom type identifier handler
(
TypeIdResolver)
to be used by
TypeSerializers
and TypeDeserializers
for converting between java types and type id included in JSON content.Annotation used for configuring details of if and how type information is
used with JSON serialization and deserialization, to preserve information
about actual class of Object instances.
Definition of standard type inclusion mechanisms for type metadata.
Definition of different type identifiers that can be included in JSON
during serialization, and used for deserialization.
Deprecated.
Since 2.5, use any Annotation type (such as
JsonTypeInfo),
if such behavior is needed; this is rarely necessary.Annotation used for binding logical name that the annotated class
has.
Annotation that can be used to explicitly define custom resolver
used for handling serialization and deserialization of type information,
needed for handling of polymorphic types (or sometimes just for linking
abstract types to concrete types)
Annotation used to indicate that a POJO-valued property should be
serialized "unwrapped" -- that is, if it would be serialized as Object value,
its properties are instead included as properties of its containing
Object -- and deserialized reproducing "missing" structure.
Marker annotation
that indicates that the value of annotated accessor (either field
or "getter" method [a method with non-void return type, no args])
is to be used as the single value to serialize for the instance,
instead of the usual method of collecting properties of value.
This enum represents the encoded format for a jsonSchema value type
Default "empty" implementation, useful as the base to start on;
especially as it is guaranteed to implement all the method
of the interface, even if new methods are getting added.
Annotation that can be used to indicate a
ValueInstantiator to use
for creating instances of specified type.Serializer class that can serialize Object that have a
JsonValue annotation to
indicate that serialization should be done by calling the method
annotated, and serializing result it returns.Annotation used for indicating view(s) that the property
that is defined by method or field annotated is part of.
General-purpose wrapper class that can be used to decorate serialized
value with arbitrary literal prefix and suffix.
Extension of
JsonStreamContext, which implements
core methods needed, and also exposes
more complete API to generator implementation classes.Token writer features specific to JSON backend.
Abstract class that defines API used for deserializing JSON content
field names into Java Map keys.
This marker class is only to be used with annotations, to
indicate that no deserializer is configured.
Interface that defines API for simple extensions that can provide additional deserializers
for deserializer Map keys of various types, from JSON property names.
Default
PolymorphicTypeValidator used unless explicit one is constructed
(and, in 2.11, MapperFeature.BLOCK_UNSAFE_POLYMORPHIC_BASE_TYPES
not enabled).Language guessing utility.
Language codes.
A set of languages.
Some languages, explicitly enumerated.
A set of utility methods to help produce consistent Object#equals(Object) and
Object#hashCode methods.
This class provides a generic implementation of the lazy initialization
pattern.
Node of a forward-only linked list.
Specialized executor to get a property from a List or array.
Specialized executor to set a property in a List or array.
Operations to assist when working with a
Locale.
Combines the monitor and visitor pattern to work with
locked objects.Wraps a domain object and a lock for access by lambdas.
This class implements a wrapper for a locked (hidden) object, and provides the means to access it.
This class implements a wrapper for a locked (hidden) object, and provides the means to access it.
A simple logging interface abstracting logging APIs.
An exception that is thrown only if a suitable
LogFactory
or Log instance cannot be created by the corresponding
factory methods.Factory for creating
Log instances, with discovery and
configuration features similar to that employed by standard Java APIs
such as JAXP.Concrete subclass of
LogFactory that implements the
following algorithm to dynamically select a logging implementation
class to instantiate a wrapper for.Set of logical types (or type categories, classes of classes), used
for defining applicability of configuration like coercion configuration.
Deprecated.
Use
LogFactory instead - The default factory
implementation performs exactly the same algorithm as this class didNumeric node that contains simple 64-bit integer values.
An interface describing the required API for the Jackson-databind Type cache.
Deprecated.
as of 3.6, use commons-text
LookupTranslator instead
Helper for simple bounded maps used for reusing lookup values.
Test application for JEXL.
Test application for JexlScriptEngine (JSR-223 implementation).
Signals that authentication challenge is in some way invalid or
illegal in the given context
Signals that a cookie is in some way invalid or illegal in a given
context
Wrapper property that is used to handle managed (forward) properties
Basically just needs to delegate first to actual forward property, and
then to back property.
Wraps a map in a context.
Basic deserializer that can take JSON "Object" structure and
construct a
Map instance, with typed contents.Basic serializer that can take JSON "Object" structure and
construct a
Map instance, with typed contents.Specialized executor to get a property from a Map.
Type that represents Map-like types; things that consist of key/value pairs
but that do not necessarily implement
Map, but that do not
have enough introspection functionality to allow for some level of generic
handling.Jackson 3 will introduce fully immutable, builder-based system for constructing
ObjectMappers.Interface that defines functionality accessible through both
serialization and deserialization configuration objects;
accessors to mode-independent configuration settings
and such.
Enumeration that defines simple on/off features to set
for
ObjectMapper, and accessible (but not changeable)
via ObjectReader and ObjectWriter (as well as
through various convenience methods through context objects).Iterator exposed by
ObjectMapper when binding sequence of
objects.Sub-class of
JsonFactory that will create a proper
ObjectCodec to allow seam-less conversions between
JSON content and Java objects (POJOs).Helper class needed to support flexible filtering of Map properties
with generic JSON Filter functionality.
Standard serializer implementation for serializing {link java.util.Map} types.
Specialized executor to set a property in a Map.
Type that represents "true" Java Map types.
Match Rating Approach Phonetic Algorithm Developed by Western Airlines in 1977.
Enumeration used to indicate strength of match between data format
and piece of data (typically beginning of a data file).
The libc crypt() "$1$" and Apache "$apr1$" MD5-based hash algorithm.
Helper class needed to be able to efficiently access class
member functions (
Methods and Constructors)
in Maps.
Definition of an interface for a wrapper around a calculation that takes a
single parameter and returns a result.
Simple
InputStream implementation that is used to "unwind" some
data previously read from an input stream; so that as long as some of
that data remains, it's returned; but as long as it's read, we'll
just use data from the underlying original stream.SettableBeanProperty implementation that will try to access value of
the property first, and if non-null value found, pass that for update
(using JsonDeserializer.deserialize(edu.internet2.middleware.grouperClientExt.com.fasterxml.jackson.core.JsonParser, edu.internet2.middleware.grouperClientExt.com.fasterxml.jackson.databind.DeserializationContext, Object))
instead of constructing a new value.Standard
MessageDigest algorithm names from the Java Cryptography Architecture Standard Algorithm Name
Documentation.Encodes a string into a Metaphone value.
Specialized executor to invoke a method on an object.
A method key usable by the introspector cache.
Simple distinguishable exception, used when
we run across ambiguous overloading.
This concrete sub-class implements property that is set
using regular "setter" method.
Deprecated.
Utility reflection methods focused on
Methods, originally from Commons BeanUtils.PrettyPrinter implementation that adds no indentation,
just implements everything necessary for value output to work
as expected, and provide simpler extension points to allow
for creating simple custom implementations that add specific
decoration or overrides.General exception type used as the base class for all
JsonMappingExceptions
that are due to input not mapping to target definition; these are typically
considered "client errors" since target type definition itself is not the root cause
but mismatching input.This singleton node class is generated to denote "missing nodes"
along paths that do not exist.
Simple interface for extensions that can be registered with
ObjectMapper
to provide a well-defined set of extensions to default functionality; such as
support for new data types.Interface Jackson exposes to modules for purpose of registering
extended functionality.
Deprecated.
use edu.internet2.middleware.morphString.Morph instead!
Morph string configuration information.
A specialized
BackgroundInitializer implementation that can deal with
multiple background initialization tasks.A data class for storing the results of the background initialization
performed by
MultiBackgroundInitializer.A
MultiKey allows multiple map keys to be merged together.Works with
ToStringBuilder to create a "deep" toString.Deprecated.
Use
MultipartRequestEntity
in conjunction with PostMethod instead.Implements a request entity suitable for an HTTP multipart POST method.
Manages a set of HttpConnections for various HostConfigurations.
Implementation of the MurmurHash2 32-bit and 64-bit hash functions.
Implementation of the MurmurHash3 32-bit and 128-bit hash functions.
Deprecated.
Use IncrementalHash32x86.
Generates 32-bit hash from input bytes.
Provides mutable access to a value.
A mutable
boolean wrapper.A mutable
byte wrapper.Mutable version of
CoercionConfig (or rather, extended API)
exposed during configuration phase of ObjectMapper
construction (via Builder).Extension of
ConfigOverride that allows changing of
contained configuration settings.A mutable
double wrapper.A mutable
float wrapper.A mutable
int wrapper.A mutable
long wrapper.A mutable
Object wrapper.A mutable pair consisting of two
Object elements.A mutable
short wrapper.A mutable triple consisting of three
Object elements.Base class for tokenized names (key strings in objects) that have
been tokenized from byte-based input sources (like
InputStream.Specialized implementation of PName: can be used for short Strings
that consists of at most 4 bytes.
Specialized implementation of PName: can be used for short Strings
that consists of 5 to 8 bytes.
Specialized implementation of PName: can be used for short Strings
that consists of 9 to 12 bytes.
Simple tag interface mostly to allow sorting by name.
Simple container class for types with optional logical name, used
as external identifier
Generic implementation of PName used for "long" names, where long
means that its byte (UTF-8) representation is 13 bytes or more.
This interface declares how to resolve a namespace from its name; it is used by the interpreter during evalutation.
Helper class used to encapsulate details of name mangling, transforming
of names using different strategies (prefixes, suffixes).
Supported types of names.
A simple class encapsulating a name/value pair.
Utilities for graal native image support; mostly to improve error message handling
in case of missing information for native image.
Netscape cookie draft specific cookie management functions
Marker class used with annotations to indicate "no class".
Signals that the target server failed to respond with a valid HTTP response.
Non-blocking parser implementation for JSON content that takes its input
via
ByteBuffer instance(s) passed.Interface used by non-blocking
JsonParser
implementations to feed input to parse.Non-blocking parser implementation for JSON content that takes its input
via
byte[] passed.Intermediate base class for non-blocking JSON parsers.
Non-blocking parser base implementation for JSON content.
bean to hold connection
Deprecated.
Trivial implementation of Log that throws away all messages.
Dummy, "no-operation" implementation of
AnnotationIntrospector.Thrown to indicate that a block of code has not been implemented.
Credentials for use with the NTLM authentication scheme which requires additional
information.An implementation of the Microsoft proprietary NTLM authentication scheme.
Bogus deserializer that will simply skip all content there is to map
and returns Java null reference.
This singleton value class is used to contain explicit JSON null
value.
Enumeration used with
JsonSetter (for properties `nulls`
and `contentNulls`)
to define how explicit `null` values from input (if input format
has the concept; JSON, for example does) are handled.Simple
NullValueProvider that will return "empty value"
specified by JsonDeserializer provider is constructed with.Simple
NullValueProvider that will simply return given
constant value when a null is encountered; or, with a specially
constructed instance (see NullsConstantProvider.skipper(), indicate the need
for special behavior of skipping property altogether (not setting
as anything OR throwing exception).This is a simple dummy serializer that will just output literal
JSON null value whenever serialization is requested.
Simple
NullValueProvider that will always throw a
InvalidNullException when a null is encountered.Helper interface implemented by classes that are to be used as
null providers during deserialization.
Container class for deserializers that handle core JDK primitive
(and matching wrapper) types, as well as standard "big" numeric types.
This is bit trickier to implement efficiently, while avoiding
overflow problems.
For type
Number.class, we can just rely on type
mappings that plain JsonParser.getNumberValue() returns.As a fallback, we may need to use this serializer for other
types of
Numbers: both custom types and "big" numbers
like BigInteger and BigDecimal.Container class for serializers used for handling standard JDK-provided
primitve number types and their wrapper counterparts (like
Integer).Shared base class for actual primitive/wrapper number serializers.
This is the special serializer for regular
Doubles (and
primitive doubles)This is the special serializer for regular
Integers
(and primitive ints)Similar to
NumberSerializers.IntegerSerializer, but will not cast to Integer:
instead, cast is to Number, and conversion is by
calling Number.intValue().Provides extra functionality for Java Number classes.
Deprecated.
as of 3.6, use commons-text
NumericEntityEscaper instead
Deprecated.
as of 3.6, use commons-text
NumericEntityUnescaper instead
Enumerates NumericEntityUnescaper options for unescaping.
Intermediate value node used for numeric nodes.
Encodes a string into a NYSIIS value.
Basic serializer that can serialize non-primitive arrays.
Generic serializer for Object arrays (
Object[]).Helper class to use for constructing Object arrays by appending entries
to create arrays of various lengths (length that is not known a priori).
Abstract class that defines the interface that
JsonParser and
JsonGenerator use to serialize and deserialize regular
Java objects (POJOs aka Beans).Wraps an Object as a Jexl context.
Definition of API used for constructing Object Identifiers
(as annotated using
JsonIdentityInfo).Simple key class that can be used as a key for
ObjectId-to-POJO mappings, when multiple ObjectId types
and scopes are used.
Container class for standard
ObjectIdGenerator implementations:
ObjectIdGenerators.IntSequenceGenerator
ObjectIdGenerators.PropertyGenerator
ObjectIdGenerators.StringIdGenerator (since 2.7)
ObjectIdGenerators.UUIDGenerator
Simple sequence-number based generator, which uses basic Java
ints (starting with value 1) as Object Identifiers.Abstract marker class used to allow explicitly specifying
that no generator is used; which also implies that no
Object Id is to be included or used.
Abstract place-holder class which is used to denote case
where Object Identifier to use comes from a POJO property
(getter method or field).
Implementation that will accept arbitrary (but unique) String Ids on
deserialization, and (by default) use random UUID generation similar
to
ObjectIdGenerators.UUIDGenerator for generation ids.Implementation that just uses
UUIDs as reliably
unique identifiers: downside is that resulting String is
36 characters long.Container object that encapsulates information usually
derived from
JsonIdentityInfo annotation or its
custom alternativesObject that knows how to deserialize Object Ids.
Definition of API used for resolving actual Java object from
Object Identifiers (as annotated using
JsonIdentityInfo).Specialized
SettableBeanProperty implementation used
for virtual property that represents Object Id that is used
for some POJO types (or properties).Object that knows how to serialize Object Ids.
ObjectMapper provides functionality for reading and writing JSON,
either to and from basic POJOs (Plain Old Java Objects), or to and from
a general-purpose JSON Tree Model (
JsonNode), as well as
related functionality for performing conversions.Customized
TypeResolverBuilder that provides type resolver builders
used with so-called "default typing"
(see ObjectMapper.activateDefaultTyping(PolymorphicTypeValidator) for details).Enumeration used with
ObjectMapper.activateDefaultTyping(PolymorphicTypeValidator)
to specify what kind of types (classes) default typing should
be used for.Node that maps to JSON Object structures in JSON content.
Builder object that can be used for per-serialization configuration of
deserialization parameters, such as root type to use or object
to update (instead of constructing new instance).
Compares Object's
Object.toString() values.Operations on
Object.Class used as a null placeholder where
null
has another meaning.Builder object that can be used for per-serialization configuration of
serialization parameters, such as JSON View and root type to use.
Helper class used for containing settings specifically related
to (re)configuring
JsonGenerator constructed for
writing output.As a minor optimization, we will make an effort to pre-fetch a serializer,
or at least relevant
TypeSerializer, if given enough
information.Deprecated.
as of 3.6, use commons-text
OctalUnescaper instead
params passed to an operation
Optional Boolean value ("nullean").
Helper class used for isolating details of handling optional+external types
(javax.xml classes) from standard factories that offer them.
Implements the HTTP OPTIONS method.
Handler class that can be used to decorate output destinations.
Automatically generated from PackageVersion.java.in during
packageVersion-generate execution of maven-replacer-plugin in
pom.xml.
Automatically generated from PackageVersion.java.in during
packageVersion-generate execution of maven-replacer-plugin in
pom.xml.
A pair consisting of two elements.
This formatter produces a textual representation of attribute/value pairs.
A simple parser intended to parse sequences of name/value pairs.
This exception is thrown when parse errors are encountered.
Intermediate base class used by all Jackson
JsonParser
implementations.Token literal values and constants.
Intermediate base class used by all Jackson
JsonParser
implementations, but does not add any additional fields that depend
on particular method of obtaining input.Token Manager.
Abstract class for one Part of a multipart post object.
Provides setters and getters for the basic Part properties.
An interface for providing access to data when posting MultiPart messages.
Implements the Percent-Encoding scheme, as described in HTTP 1.1 specification.
Converts words into potential phonetic representations.
Helper type used when introspecting bindings for already resolved types,
needed for specialization.
DISCLAIMER: HttpClient developers DO NOT actively support this component.
A utility class that gives applets the ability to detect proxy host settings.
Value node that contains a wrapped POJO, to be serialized as
a JSON constructed through data mapping (usually done by
calling
ObjectMapper).Helper class used for aggregating information about all possible
properties of a POJO.
Helper class used for aggregating information about a single
potential POJO property.
Node used for creating simple linked lists to efficiently store small sets
of things.
Interface for classes that handle validation of class-name - based subtypes used
with Polymorphic Deserialization: both via "default typing" and explicit
@JsonTypeInfo when using Java Class name as Type Identifier.Shared base class with partial implementation (with all validation calls returning
PolymorphicTypeValidator.Validity.INDETERMINATE) and convenience methods for indicating failure reasons.Definition of return values to indicate determination regarding validity.
Implements the HTTP POST method.
Interface for objects that implement pretty printer functionality, such
as indentation.
Base class for specialized primitive array builders.
Container for deserializers used for instantiating "primitive arrays",
arrays that contain non-object java primitive types.
A hash table supporting full concurrency of retrievals, adjustable expected
concurrency for updates, and a maximum capacity to bound the map by.
A builder that creates
PrivateMaxEntriesMap instances.The
Processor represents a microprocessor and defines
some properties like architecture and type of the microprocessor.The
Processor.Arch enum defines the architecture of
a microprocessor.The
Processor.Type enum defines types of a microprocessor.Enumeration used to define kinds of elements (called "property accessors")
that annotations like
JsonAutoDetect apply to.Object that is used to collect arguments for non-default creator
(non-default-constructor, or argument-taking factory method)
before creator can be called.
Base class for
JsonMappingExceptions that are specifically related
to problems related to binding an individual property.Helper class for
BeanSerializerFactory that is used to
construct BeanPropertyWriter instances.Interface that defines API for filter objects use (as configured
using
JsonFilter)
for filtering bean properties to serialize.Specialized executor to get a property from an object.
Simple container class used for storing "additional" metadata about
properties.
Helper class used for containing information about expected merge
information for this property, if merging is expected.
Simple value class used for containing names of properties as defined
by annotations (and possibly other configuration sources).
Container for standard
PropertyNamingStrategy implementations
and singleton instances.Naming strategy similar to
PropertyNamingStrategies.SnakeCaseStrategy,
but instead of underscores
as separators, uses hyphens."No-operation" strategy that is equivalent to not specifying any
strategy: will simply return suggested standard bean naming as-is.
Simple strategy where external name simply only uses lower-case characters,
and no separators.
Naming strategy similar to
PropertyNamingStrategies.KebabCaseStrategy,
but instead of hyphens
as separators, uses dots.Intermediate base class for simple implementations
A
PropertyNamingStrategy that translates typical camel case Java
property names to lower case JSON element names, separated by
underscores.A
PropertyNamingStrategy that translates typical camelCase Java
property names to PascalCase JSON element names (i.e., with a capital
first letter).A
PropertyNamingStrategy that translates an input to the equivalent upper case snake
case.Class that defines how names of JSON properties ("external names")
are derived from names of POJO methods and fields ("internal names"),
in cases where no explicit annotations exist for naming.
Deprecated.
Since 2.12 use
PropertyNamingStrategies.KebabCaseStrategy instead
(see
databind#2715
for reason for deprecation)Deprecated.
Since 2.12 use
PropertyNamingStrategies.LowerCaseStrategy instead
(see
databind#2715
for reason for deprecation)Deprecated.
In 2.7 use
PropertyNamingStrategies.SnakeCaseStrategy insteadDeprecated.
Since 2.12 use
PropertyNamingStrategies.LowerDotCaseStrategy instead
(see
databind#2715
for reason for deprecation)Deprecated.
In 2.7 use
PropertyNamingStrategies.UpperCamelCaseStrategy insteadDeprecated.
Since 2.12 deprecated.
Deprecated.
Since 2.12 use
PropertyNamingStrategies.SnakeCaseStrategy instead
(see
databind#2715
for reason for deprecation)Deprecated.
Since 2.12 use
PropertyNamingStrategies.UpperCamelCaseStrategy instead
(see
databind#2715
for reason for deprecation)Helper container used for resolving serializers for dynamic (possibly but not
necessarily polymorphic) properties: properties whose type is not forced
to use dynamic (declared) type and that are not final.
Value class used for returning tuple that has both serializer
that was retrieved and new map instance
Specialized executor to set a property in an object.
Base class for property values that need to be buffered during
deserialization.
Simple container used for temporarily buffering a set of
PropertyValues.Base class for writers used to output property values (name-value pairs)
as key/value pairs via streaming API.
A class to encapsulate the specifics of a protocol.
Signals that an HTTP protocol violation has occurred.
A factory for creating Sockets.
A client that provides
sockets for communicating through HTTP proxies
via the HTTP CONNECT method.Contains the method used to execute the connect along with the created socket.
Signals a problem with auto-detecting the proxy information using the java
plugin.
Holds all of the variables needed to describe an HTTP connection to a proxy.
A pure-java implementation of the CRC32 checksum that uses
the same polynomial as the built-in native CRC32.
A pure-java implementation of the CRC32 checksum that uses
the CRC32-C polynomial, the same polynomial used by iSCSI
and implemented on many Intel chipsets supporting SSE4.2.
Implements the HTTP PUT method.
Similar to the Quoted-Printable content-transfer-encoding defined in
RFC 1521 and designed to allow text containing mostly ASCII
characters to be decipherable on an ASCII terminal without decoding.
Codec for the Quoted-Printable section of RFC 1521.
Generates random
Strings.Utility library that supplements the standard
Random class.An immutable range of objects from a minimum to maximum point inclusive.
This is a simple dummy serializer that will just output raw values by calling
toString() on value to serialize.
Helper class used to encapsulate "raw values", pre-encoded textual content
that can be output as opaque value with no quoting/escaping, using
JsonGenerator.writeRawValue(String).Simple value container for containing information about single Object Id
during deserialization
This is a concrete implementation of
JsonParser, which is
based on a Reader to handle low-level character
conversion tasks.Optimized lookup table for accessing two types of serializers; typed
and non-typed.
A readonly context wrapper.
Works with
ToStringBuilder to create a "deep" toString.Signals violation of HTTP specification caused by an invalid redirect
Specialized
SimpleType for types that are referential types,
that is, values that can be dereferenced to another value (or null),
of different type.Base deserializer implementation for properties
ReferenceType values.Base implementation for values of
ReferenceType.Encodes a string into a Refined Soundex value.
Assists in implementing
Diffable.diff(Object) methods.This helper class uses refelction in order to execute Socket methods
available in Java 1.4 and above
Assists in implementing
Object.toString() methods using reflection.Helpers to process Strings using regular expressions.
Container object used to contain optional information on content
being parsed, passed to
JsonParseException in case of
exception being thrown; this may be useful for caller to display
information on failure.Interface used to indicate deserializers that want to do post-processing
after construction but before being returned to caller (and possibly cached)
and used.
Interface used to indicate serializers that want to do post-processing
after construction and being added to
SerializerProvider,
but before being used.Internal placeholder type used for self-references.
Type abstraction that represents Java type that has been resolved
(i.e.
Consider this class package private.
has result metadata
RFC 2109 specific cookie management functions
Abstract authentication scheme class that lays foundation for all
RFC 2617 compliant authetication schemes and provides capabilities common
to all authentication schemes defined in RFC 2617.
RFC 2965 specific cookie management functions.
Helper class for caching resolved root names.
A phoneme rule.
A minimal wrapper around the functionality of Pattern that we use, to allow for alternate implementations.
Types of rule.
Wrapper used when interface does not allow throwing a checked
JsonMappingExceptionA sandbox describes permissions on a class by explicitly allowing or forbidding access to methods and properties
through "whitelists" and "blacklists".
A black set of names.
A base set of names.
Contains the white or black lists for properties and methods for a given class.
A white set of names.
An uberspect that controls usage of properties, methods and contructors through a sandbox.
save mode for static saves.
Marker interface for schema-aware serializers.
A JEXL Script.
A ProtocolSocketFactory that is secure.
Efficient alternative to
StringWriter, based on using segmented
internal buffer.Value class used with some
PrettyPrinter
implementsWriter class similar to
ObjectWriter, except that it can be used
for writing sequences of values, not just a single value.Generic handler for types that implement
JsonSerializable.Interface that defines how Jackson package can interact with efficient
pre-serialized or lazily-serialized and reused String representations.
Object that contains baseline configuration for serialization
process.
Exception thrown when the Serialization process fails.
Enumeration that defines simple on/off features that affect
the way Java objects are serialized.
Assists with the serialization process and performs additional functionality based
on serialization.
String token that can lazily serialize String contained and then reuse that
serialization later on.
Simple cache object that allows for doing 2-level lookups: first level is
by "local" read-only lookup Map (used without locking)
and second backup level is by a shared modifiable HashMap.
Abstract class that defines API used by
SerializerProvider
to obtain actual
JsonSerializer instances from multiple distinct factories.Configuration settings container class for
SerializerFactory implementations.Class that defines API used by
ObjectMapper and
JsonSerializers to obtain serializers capable of serializing
instances of specific types; as well as the default implementation
of the functionality.Interface that defines API for simple extensions that can provide additional serializers
for various types.
Basic
Serializers implementation that implements all methods but provides
no serializers.Class that represents a "wildcard" set method which can be used
to generically set values of otherwise unmapped (aka "unknown")
properties read from JSON content.
Base class for deserializable properties of a bean: contains
both type and name definitions, and reflection-based set functionality.
Helper class that is designed to both make it easier to sub-class
delegating subtypes and to reduce likelihood of breakage when
new methods are added.
This concrete sub-class implements Collection or Map property that is
indirectly by getting the property value and directly modifying it.
SHA2-based Unix crypt implementation.
Numeric node that contains simple 16-bit integer values.
Simple
AbstractTypeResolver implementation, which is
based on static mapping from abstract super types into
sub types (concrete or abstract), but retaining generic
parameterization.Simple immutable
BeanPropertyDefinition implementation that can
be wrapped around a AnnotatedMember that is a simple
accessor (getter) or mutator (setter, constructor parameter)
(or both, for fields).Simple
PropertyFilter implementation that only uses property name
to determine whether to serialize property as is, or to filter it out.Filter implementation which defaults to filtering out unknown
properties and only serializes ones explicitly listed.
Filter implementation which defaults to serializing all
properties, except for ones explicitly listed to be filtered out.
An implementation of interface CharStream, where the stream is assumed to
contain only ASCII characters (without unicode processing).
Simple implementation
Deserializers which allows registration of
deserializers based on raw (type erased class).Simple
FilterProvider implementation that just stores
direct id-to-filter mapping.A connection manager that provides access to a single HttpConnection.
Simple implementation
KeyDeserializers which allows registration of
deserializers based on raw (type erased class).Simple implementation of Log that sends all enabled log messages,
for all defined loggers, to System.err.
Simple implementation of
ClassIntrospector.MixInResolver
that just uses a Map for containing mapping
from target to mix-in classes.Vanilla
Module implementation that allows registration
of serializers and deserializers, bean serializer
and deserializer modifiers, registration of subtypes and mix-ins
as well as some other commonly
needed aspects (addition of custom AbstractTypeResolvers,
ValueInstantiators).A class originally generated by JJTree with the following JavaCCOptions:
MULTI=true,NODE_USES_PARSER=true,VISITOR=true,TRACK_TOKENS=false,NODE_PREFIX=AST,NODE_EXTENDS=,NODE_FACTORY=
Works around issue https://javacc.dev.java.net/issues/show_bug.cgi?id=227
As soon as this issue if fixed and the maven plugin uses the correct version of Javacc, this
class can go away.
Simple implementation of
ObjectIdResolverSimple implementation
Serializers which allows registration of
serializers based on raw (type erased class).Simple types are defined as anything other than one of recognized
container types (arrays, Collections, Maps).
Author: Mark Claassen
Encodes a string into a Soundex value.
Serializer implementation for
Blob to write as binary
(for JSON and other formats Base64-encoded String, for binary formats as
true binary).Compared to regular
Date serialization, we do use String
representation here.A SecureProtocolSocketFactory that uses JSSE to create sockets.
Intermediate class used both for convenience of binding and
to support
PropertyNamingStrategy.Works with
ToStringBuilder to create a toString.Intermediate base class for Lists, Collections and Arrays
that contain static (non-dynamic) value types.
Benchmark statistics
Represents a Status-Line as returned from a HTTP server.
Dummy container class to group standard homogenous array serializer implementations
(primitive arrays and String array).
Character arrays are different from other integral number arrays in that
they are most likely to be textual data, and should be written as
Strings, not arrays of entries.
Intermediate base class used for cases where we may add
type information (excludes boolean/int/double arrays).
Standard implementation of
Converter that supports explicit
type access, instead of relying type detection of generic type
parameters.Jackson's internal
DateFormat implementation used by standard Date
serializers and deserializers to implement default behavior: does NOT
fully implement all aspects expected by DateFormat and as a consequence
SHOULD NOT to be used by code outside core Jackson databind functionality.Deserializer implementation where given Java type is first deserialized
by a standard Jackson deserializer into a delegate type; and then
this delegate type is converted using a configured
Converter into desired target type.Serializer implementation where given Java type is first converted
to an intermediate "delegate type" (using a configured
Converter, and then this delegate value is serialized by Jackson.Base class for common deserializers.
Class that providers access to serializers user for non-structured JDK types that
are serializer as scalars; some using basic
ToStringSerializer,
others explicit serializers.Default
KeyDeserializer implementation used for most Map
types Jackson supports.Helper class used to contain simple/well-known key deserializers.
Deprecated.
Since 2.8, use
StdKeySerializers.Default instead.This is a "chameleon" style multi-type key serializer for simple
standard JDK types.
Key serializer used when key type is not known statically, and actual key
serializer needs to be dynamically located.
Specialized instance to use for Enum keys, as per [databind#1322]
Simple and fast key serializer when keys are Strings.
Convenience deserializer that may be used to deserialize values given an
intermediate tree representation (
JsonNode).Base class for deserializers that handle types that are serialized
as JSON scalars (non-structured, i.e.
Base class used by all standard serializers, and can also
be used for custom serializers (in fact, this is the recommended
base class to use).
Standard
SubtypeResolver implementation.Default
TypeResolverBuilder implementation.Default
ValueInstantiator implementation, which supports
Creator methods that can be indicated by standard Jackson
annotations.scope of groups under a stem.
StopWatch provides a convenient API for timings.Deprecated.
as of 3.6, use commons-text
TextStringBuilder instead
Set of on/off capabilities that a
JsonParser for given format
(or in case of buffering, original format) has.Intermediate base class for all read-side streaming processing problems, including
parsing and input value coercion problems.
Token reader (parser) features not-specific to any particular format backend.
Provides utility functions, and classes for working with the
java.util.stream package, or more generally, with Java 8 lambdas.Deprecated.
Use
Streams.A Collector type for arrays.
Deprecated.
A reduced, and simplified version of a
Stream with failable method signatures.Deprecated.
Set of on/off capabilities that a
JsonGenerator for given format
(or in case of buffering, original format) has.Intermediate base class for all read-side streaming processing problems, including
parsing and input value coercion problems.
Token writer (generator) features not-specific to any particular format backend.
A
SecureProtocolSocketFactory that uses JSSE to create
SSL sockets.Separate implementation for serializing String arrays (instead of
using
ObjectArrayDeserializer.Standard serializer used for
String[] values.Specifically optimized version for
Collections
that contain String values; reason is that this is a very common
type and we can make use of the fact that Strings are final.Efficient implement for serializing
Collections that contain Strings.Defines common decoding methods for String decoders.
Defines common encoding methods for String encoders.
Compares Strings using a
StringEncoder.Deprecated.
as of 3.6, use commons-text
StringEscapeUtils instead
Common constant strings utilities.
Simple string parameter for a multipart post
A RequestEntity that contains a String.
This is the special serializer for regular
Strings.Converts String to and from bytes using the encodings required by the Java specification.
Operations on
String that are
null safe.Deprecated.
as of 3.6, use commons-text
StringLookupFactory instead
Deprecated.
as of 3.6, use commons-text
StringMatcherFactory instead
Deprecated.
as of 3.6, use commons-text
StringSubstitutor instead
Deprecated.
as of 3.6, use commons-text
StringTokenizer instead
Helper object used for handling registration on resolving of super-types
to sub-types.
Helper class used to encapsulate rules that determine subtypes that
are invalid to use, even with default typing, mostly due to security
concerns.
Helpers for
java.lang.System.TextBuffer is a class similar to
StringBuffer, with
following differences:
TextBuffer uses segments character arrays, to avoid having
to do additional array copies when array is not big enough.Value node that contains a text value.
Helpers for
java.lang.Thread and java.lang.ThreadGroup.A predicate implementation which matches a thread or threadgroup name.
A predicate for selecting threadgroups.
A predicate implementation which matches a thread id.
A predicate for selecting threads.
A simple implementation of the Circuit Breaker pattern
that opens if the requested increment amount is greater than a given threshold.
Deserializer that builds on basic
BeanDeserializer but
override some aspects like instance construction.
A specialized semaphore implementation that provides a number of
permits in a given time frame.
Executes a task with a specified timeout.
Signals that the task timed out.
Helps to deal with
TimeZones.A function that accepts two arguments and produces a boolean result.
Simple "bogus" serializer that will just serialize an empty
Object for any given value.
Describes the input token stream.
Utility class used for efficient storage of
JsonToken
sequences, needed for temporary buffering.Individual segment of TokenBuffer that can store up to 16 tokens
(limited by 4 bits per token type marker requirement).
We also want to directly support deserialization of
TokenBuffer.Implementation of
JsonStreamContext used by TokenBuffer
to link back to the original context to try to keep location information
consistent between source location and buffered content when it's re-read
from the buffer.We also want to directly support serialization of
TokenBuffer;
and since it is part of core package, it cannot implement
JsonSerializable
(which is only included in the mapper package)Strategy class that can be implemented to specify actual inclusion/exclusion
criteria for filtering, used by
FilteringGeneratorDelegate.Enumeration that controls how TokenFilter return values are interpreted.
Alternative variant of
JsonStreamContext, used when filtering
content being read or written (based on TokenFilter).Token Manager Error.
Intermediate base class for actual format-specific factories for constructing
parsers (reading) and generators (writing).
Assists in implementing
Object.toString() methods.Use this annotation to exclude a field from being used by
the
ReflectionToStringBuilder.Simple general purpose serializer, useful for any
type for which
Object.toString() returns the desired JSON
value.Intermediate base class that serves as base for standard
ToStringSerializer
as well as for custom subtypes that want to add processing for converting from
value to output into its String representation (whereas standard version
simply calls value object's toString() method).Controls
String formatting for ToStringBuilder.Use this annotation on the fields to get the summary instead of the detailed
information when using
ReflectionToStringBuilder.Implements the HTTP TRACE method.
Interface that defines objects that can read and write
TreeNode instances using Streaming API.Marker interface used to denote JSON Tree nodes, as far as
the core package knows them (which is very little): mostly
needed to allow
ObjectCodec to have some level
of interoperability.Facade over
JsonNode that implements JsonParser to allow
accessing contents of JSON tree in alternate form (stream of tokens).Represents a function that accepts three arguments and produces a result.
A triple consisting of three elements.
Since 2.10, Builder class is offered for creating token stream factories
with difference configurations: with 3.x they will be fully immutable.
Helper class used for resolving type parameters for given class
Generalization of "has a type."
Interface for deserializing type information from JSON content, to
type-safely deserialize data into correct polymorphic instance
(when type inclusion has been enabled for type handled).
Base class for all standard Jackson
TypeDeserializers.Class used for creating concrete
JavaType instances,
given various inputs.Interface that defines standard API for converting types
to type identifiers and vice versa.
Partial base implementation of
TypeIdResolver: all custom implementations
are strongly recommended to extend this class, instead of directly
implementing TypeIdResolver.Key that offers two "modes"; one with raw class, as used for
cases were raw class type is available (for example, when using
runtime type); and one with full generics-including.
Type literal comparable to
javax.enterprise.util.TypeLiteral,
made generally available outside the JEE context.Class that defines API that can be used to modify details of
JavaType instances constructed using TypeFactory.Simple recursive-descent parser for parsing canonical
JavaType
representations and constructing type instances.This generic abstract class is used for obtaining full generics type information
by sub-classing; it must be converted to
ResolvedType implementation
(implemented by JavaType from "databind" bundle) to be used.Interface that defines API used by members (like
AnnotatedMethod)
to dynamically resolve types they have.Dummy implementation for case where there are no bindings available
(for example, for static methods and fields)
Interface that defines builders that are configured based on
annotations (like
JsonTypeInfo or JAXB annotations),
and produce type serializers and deserializers used for
handling type information embedded in JSON to allow for safe
polymorphic type handling.Interface for serializing type information regarding instances of specified
base type (super class), so that exact subtype can be properly deserialized
later on.
Utility methods focusing on type inspection, particularly with regard to
generics.
WildcardType builder.Simple deserializer that will call configured type deserializer, passing
in configured data deserializer, and exposing it all as a simple
deserializer.
Simple serializer that will call configured type serializer, passing
in configured data serializer, and exposing it all as a simple
serializer.
'Federated' introspection/reflection interface to allow the introspection
behavior in JEXL to be customized.
Implementation of Uberspect to provide the default introspective
functionality of JEXL.
Deprecated.
Do not use externally - will be made private in a later version
Deprecated.
Do not use externally - will be made private in a later version
A generic indexed property container, exposes get(key) and set(key, value) and solves method call dynamically
based on arguments.
Deprecated.
as of 3.6, use commons-text
UnicodeEscaper instead
Deprecated.
as of 3.6, use commons-text
UnicodeUnescaper instead
Deprecated.
as of 3.6, use commons-text
UnicodeUnpairedSurrogateRemover instead
An evaluator similar to the Unified EL evaluator used in JSP/JSF based on JEXL.
The sole type of (runtime) exception the UnifiedJEXL can throw.
Unix crypt(3) algorithm implementation.
Specialized
JsonMappingException sub-class specifically used
to indicate problems due to encountering a JSON property that could
not be mapped to an Object property (via getter, constructor argument
or field).Exception thrown during deserialization when there are object id that can't
be resolved.
Helper class for
UnresolvedForwardReference, to contain information about unresolved ids.Special bogus "serializer" that will throw
MismatchedInputException
if an attempt is made to deserialize a value.Special bogus "serializer" that will throw
InvalidDefinitionException if its UnsupportedTypeSerializer.serialize(java.lang.Object, edu.internet2.middleware.grouperClientExt.com.fasterxml.jackson.core.JsonGenerator, edu.internet2.middleware.grouperClientExt.com.fasterxml.jackson.databind.SerializerProvider)
gets invoked.Deserializer implementation that is used if it is necessary to bind content of
"unknown" type; something declared as basic
Object
(either explicitly, or due to type erasure).Deprecated.
Object that is responsible for handling acrobatics related to
deserializing "unwrapped" values; sets of properties that are
embedded (inlined) as properties of parent JSON object.
Variant of
BeanPropertyWriter which will handle unwrapping
of JSON Object (including of properties of Object within surrounding
JSON object, and not as sub-object).The interface for the URI(Uniform Resource Identifiers) version of RFC 2396.
The charset-changed normal operation to represent to be required to
alert to user the fact the default charset is changed.
A mapping to determine the (somewhat arbitrarily) preferred charset for a
given locale.
The URI parsing and escape encoding exception.
The URI escape and character encoding and decoding utility.
Deprecated.
use edu.internet2.middleware.grouperClientExt.org.apache.commons.codec.net.URLCodec
Implements the 'www-form-urlencoded' encoding scheme, also misleadingly known as URL encoding.
Username and password
Credentials.Since JDK does not come with UTF-32/UCS-4, let's implement a simple
decoder to use.
This is a concrete implementation of
JsonParser, which is
based on a DataInput as the input source.This is a concrete implementation of
JsonParser, which is
based on a InputStream as the input source.Specialized
JsonSerializer to output UUIDs.This class assists in validating arguments.
Class that encapsulates details of value injection that occurs before
deserialization of a POJO.
Exception type used for generic failures during processing by
ValueInstantiator:
commonly used to wrap exceptions thrown by constructor or factory
method.Class that defines simple API implemented by objects that create value
instances.
Partial
ValueInstantiator implementation that is strongly recommended
to be used instead of directly extending ValueInstantiator itself.Delegating
ValueInstantiator implementation meant as a base type
that by default delegates methods to specified fallback instantiator.Interface for providers of
ValueInstantiator instances.Basic "NOP" implementation that can be used as the base class for custom implementations.
This intermediate base class is used for all leaf nodes, that is,
all non-container (array or object) nodes, except for the
"missing node".
Object that encapsulates versioning information of a component.
Interface that those Jackson components that are explicitly versioned will implement.
Functionality for supporting exposing of component
Versions.Helper class used for checking whether a property is visible
in the active view
Placeholder used by virtual properties as placeholder for
underlying
AnnotatedMember.BeanPropertyWriter implementation used with
JsonAppend
to add "virtual" properties in addition to regular ones.Interface for object used for determine which property elements
(methods, fields, constructors) can be auto-detected, with respect
to their visibility modifiers.
Default standard implementation is purely based on visibility
modifier of given class members, and its configured minimum
levels.
Implementation of
Hashtable that uses WeakReference's
to hold its keys thus allowing them to be reclaimed by the garbage collector.Deprecated.
as of 3.6, use commons-text
WordUtils instead
Simple value container used to keep track of Object Ids during
serialization.
This is a simple value class used between core streaming and higher level
databinding to pass information about type ids to write.
Enumeration of values that matches enum `As` from annotation
`JsonTypeInfo`: separate definition to avoid dependency between
streaming core and annotations packages; also allows more flexibility
in case new values needed at this level of internal API.
JsonGenerator that outputs JSON content using a Writer
which handles character encoding.Result of one subject being added to a group.
results for the add member call.
If sending in attribute assignments in batch, this is one of the entries
holds an attribute assign result.
returned from the attribute def name inheritance
holds an attribute assign result.
results for assigning attributes call.
results for assigning attributes call.
results for assigning attributes call.
Result of assigning or removing a privilege
Result of assigning or removing a privilege
Result of assigning or removing a privilege
holds a permission assign result.
results for assigning permissions call.
results for assigning permissions call.
result of attribute assign query represents an assignment in the DB
an item in the attribute assign action result list
Class to lookup an attribute assignment via web service
value of an attribute assign
holds an attribute assign result.
holds an attribute assign result.
Result of one attribute def name being retrieved.
item in the assign attribute def action result
holds result of assign action to attribute def request.
Result of one attribute def being deleted.
results for the attribute defs delete call.
Class to lookup an attribute def via web service
Result of one attribute def name being retrieved.
Result of one attribute def name being deleted.
results for the attribute def names delete call.
Class to lookup an attribute def name via web service
Result of one AttributeDefName being saved.
results for the attribute def names save call.
Class to save an attribute def name via web service
Result of one AttributeDef being saved.
results for the attribute defs save call.
Class to save an attribute def via web service
Result of one subject being deleted from a group.
results for the delete member call.
Result of one external subject being retrieved.
Result of one external subject attribute being retrieved.
Result of one externalSubject being deleted.
results for the external subjects delete call.
Class to lookup an attribute def via web service
developers make sure each setter calls this.clearAttributeDef();
Result of one external being saved.
results for the groups save call.
Class to save a external subject via web service
returned from the attribute def name find query
returned from the attribute def find query
returned from the external subject find query
returned from the group find query
returned from the stem find query, if none found, return none
returned from the attribute assign actions query
results for the get attributeAssignments call.
results for the get audit entries call.
Result of retrieving privileges for a user/group combo (and perhaps
filtered by type), will
return a list of permissions
results for the get groups call.
results for the get groups call.
results for the get memberships call, or the get memberships lite call
result code:
code of the result for this group overall
SUCCESS: means everything ok
GROUP_NOT_FOUND: cant find the group
INVALID_QUERY: bad inputs
EXCEPTION: something bad happened
results for the get members call.
results for the get members call.
results for the get permissionAssignments call.
results for the get memberships call, or the get memberships lite call
result code:
code of the result for this group overall
SUCCESS: means everything ok
GROUP_NOT_FOUND: cant find the group
INVALID_QUERY: bad inputs
EXCEPTION: something bad happened
Result of one group being retrieved since a user is a member of it.
Result of one group being deleted.
results for the groups delete call.
Result for finding a group
Query for one privilege.
Class to lookup a group via web service
developers make sure each setter calls this.clearGroup();
Result of one group being saved.
results for the groups save call.
Class to save a group via web service
Result of seeing if one subject is a member of a group.
results for the has member call.
Class with data about a member who's subject needs to change
Result of one member changing its subject
results for the member change subject call.
member filter for retrieving members.
Result of one member being retrieved from a group.
Class to lookup a membership via web service.
Class to lookup a membership via web service.
Result of one message being sent or received.
returned from the acknowledge message web service
returned from the send/receive message web service
param for a web service operation
result of permission entry query represents an assignment in the DB
result of permission entry query represents an assignment in the DB
param for permission query if there are run time limits this is the runtime data
represents a limit on a permission.
this represents a query which can be and'ed or or'ed
Bean (used in Rest) as a request for web service
bean (used in Rest) which is a response from web service
response metadata (version, warnings, etc)
request bean in body of rest request
bean that will be the data from rest request
request bean in body of rest request
Add/Remove/Replace actions from attribute def
request bean in body of rest request
request bean in body of rest request.
request bean in body of rest request
request bean in body of rest request
Class with data about assigning privileges for a subject and group
Class with data about assigning privileges for a subject and group
request bean in body of rest request
request bean in body of rest request
request bean in body of rest request
request bean in body of rest request
request bean in body of rest request
request bean in body of rest request
bean that will be the data from rest request
for method
bean that will be the data from rest request
see GrouperServiceLogic#getGroups(edu.internet2.middleware.grouper.ws.GrouperWsVersion, WsSubjectLookup[], edu.internet2.middleware.grouper.ws.member.WsMemberFilter, WsSubjectLookup, boolean, boolean, String[], WsParam[])
for method
bean that will be the data from rest request
see GrouperServiceLogic#getGroups(edu.internet2.middleware.grouper.ws.GrouperWsVersion, WsSubjectLookup[], edu.internet2.middleware.grouper.ws.member.WsMemberFilter, WsSubjectLookup, boolean, boolean, String[], WsParam[])
for method
request bean in body of rest request
request bean in body of rest request
bean that will be the data from rest request
see GrouperServiceLogic#getGroups(edu.internet2.middleware.grouper.ws.GrouperWsVersion, WsSubjectLookup[], edu.internet2.middleware.grouper.ws.member.WsMemberFilter, WsSubjectLookup, boolean, boolean, String[], WsParam[])
for method
bean that will be the data from rest request
for method
bean that will be the data from rest request
Bean for rest request to get attributes assign actions
Class with data about retrieving privileges for a subject and group
bean that will be the data from rest request
for method
bean that will be the data from rest request
GrouperServiceLogic#getMemberships(edu.internet2.middleware.grouper.ws.GrouperWsVersion, WsGroupLookup[], WsSubjectLookup[], edu.internet2.middleware.grouper.ws.member.WsMemberFilter, WsSubjectLookup, edu.internet2.middleware.grouper.Field, boolean, String[], boolean, WsParam[], String[], String, edu.internet2.middleware.grouper.ws.soap.WsStemLookup, edu.internet2.middleware.grouper.ws.query.StemScope, String, String[])
for method
bean that will be the data from rest request
for method
Bean for rest request to get permissions lite
Bean for rest request to get permissions
request bean for rest get subjects lite request
bean that will be the data from rest request
bean that will be the data from rest request
bean that will be the data from rest request
bean that will be the data from rest request
for method
request bean for rest member change subject lite
request bean in body of rest request
request bean in body of rest request
bean that will be the data from rest request
for method
bean that will be the data from rest request
result metadata (if success, result code, etc) for one result
(each ws call can have one or many result metadatas)
Result for finding a stem
Result of one stem being deleted.
results for the stems delete call.
Class to lookup a stem via web service
this represents a query which can be and'ed or or'ed
Result of one save being saved.
results for the stems save call.
Class to save a stem via web service
subject bean for web services
template to lookup a subject.
indent xml, assumes the input is not yet indented.
Implementation of the xxhash32 hash algorithm.