All Classes

Class	Description
AbstractBaseUtility	The base class for each Utilities class that contains common functions to all
AbstractCommonIntegrationExecutor	Superclass containing common hooks for the custom integration executor classes
AbstractJavaDataSource	Parent class for Java data sources, making certain things easier
AbstractNamedParameterStatement<StatementType extends Statement>	The abstract superclass for the named parameter statement types.
AbstractThreadedObjectIteratorTask<ItemType>	A more advanced AbstractThreadedTask that implements a “do this to these” pattern.
AbstractThreadedObjectIteratorTask.CloseableIteratorWrapper	Proxy to convert a Closeable iterator into an iterator
AbstractThreadedTask<T>	An abstract superclass for nearly all custom multi-threaded SailPoint tasks.
AccessCheck	Static methods for implementing access checks.
AccessCheck.SecurityCacheToken	The container object to identify the cached ThingAccessUtil inputs.
AccessCheck.SecurityResult	The container object to hold the cached ThingAccessUtil results
AccessCheckInput	Access check input
AccessCheckResponse	The output of AccessCheck.accessCheck(AccessCheckInput).
AccessHistory	A singleton utility for retrieving AccessHistory-related objects, gracefully failing in pre-8.4 versions of IIQ.
AccessRequestUtilities	Utility class for dealing with Approvals, ApprovalSets, and ApprovalItems
AccountAggregationExecutor	Request handler to do an async execution of a single aggregation event.
AccountUtilities	This class contains several utilities for dealing with accounts and applications
AccountUtilities.AggregateOptions	The options class for AccountUtilities.aggregateAccount(AggregateOptions), allowing expansion of the inputs without having to break backwards compatibility.
AggregationDateRetentionService	A service to retain the last aggregation timestamps and other cache data for Applications in a Custom object called “Aggregation Date Storage”.
AggregationOutcome	A data class for returning the outcome of the aggregation event
AssignedDetectedRoleDifferenceCleanup	Assigned role differences detection task.
AuthorizeAll	Indicates that the API method ought to authorize the user only if they are authorized by all of the AuthorizedBy sub-elements.
AuthorizeAny
AuthorizedBy
AuthUtilities	Utilities for authorization, e.g., whether a user can view a QuickLink.
AuthUtilities.QuickLinkAccessType	Indicates the type of access to a QuickLink we are checking
BaseCommonPluginResource	This class is the common base class for all IIQCommon-compliant plugin REST resources.
BaseCommonPluginResource.PluginAction	The interface that must be implemented by any plugin action passed to BaseCommonPluginResource.handle(Authorizer, PluginAction).
BaseCommonPluginService	Deprecated. Extend BaseCommonService and implement PluginContext instead so I don’t have to keep maintaining this code twice.
BaseCommonService	Abstract super-class for services.
BaseDelegatingConnector	A straightforward “delegating” connector that will allow loading of connector classes from a plugin.
BaseIdentityUtilities	Utilities for handling Identity operations
BaseServiceImplementation	Interface to ensure that nobody breaks the contract of BaseCommonService
BasicObjectRetriever<ItemType>	Implements a reusable implementation of ObjectRetriever for use with any number of scheduled tasks.
BatchingIterator<ObjectType>	An iterator that batches up the inputs into batches of size ‘batchSize’, then returns them in chunks.
BeanshellUtilities	Utilities for working with Beanshell at a language level
BetterDifferencer	An API to reimplement the Differencer to increase its reliability with various Sailpoint objects.
CacheEntry<T>	Cache entry for use with the CacheMap class or other purposes.
CacheGenerator<T>	This interface represents a factory for objects of type T
CacheMap<K,V>	Implements a Cache that exposes itself as a regular Map.
Caches	Static implementations of specific commonly-used caches
CaptureLogs	An interface to abstract the log capturing between 7.x (which uses log4j) and 8.x (which uses log4j2)
CaptureLogs7	Captures the most interesting logs for IIQ 7.x by hooking into Log4j 1.x
CaptureLogs7.CaptureLogs7Appender	The new appender that will log the messages if we’re tracking them and also pass them on to the original logger if we’re higher than the original level.
CaptureLogs8	Capture logs in IIQ 8, which uses Log4J 2.x.
Cell	A class representing a single cell in an HTML table.
CellOption	A cell modifier that can be passed in to various methods
CellOptions	A class implementing a variety of static cell options.
CleanupLinksPartition
CloseableIteratorAdapter<T>	A wrapper class for IIQ’s CloseableIterator that still implements CloseableIterator, but also implement the broader Iterator and AutoClosable interfaces to allow regular Java stuff to interact with it.
ColumnConfig	A wrapper around the various ways of structuring report columns.
ColumnToken	The generic implementation of a colon-separated column token, e.g., ‘col1:blah:stuff’.
CommonConstants	Some constants that will be useful in many IIQ scenarios.
CommonExtendedPluginContext	An interface to ensure that the BaseCommonPlugin* classes all implement the same methods
CommonPluginUtils	Some utilities to avoid boilerplate
CommonPluginUtils.SingleServerExecute	The executor passed to CommonPluginUtils.singleServerExecute(SailPointContext, ServiceDefinition, SingleServerExecute) mainly so that we can extend it with those default methods and throw an exception from run().
CommonSecurityConfig	This is the implementation of the Common Security configuration object, as expected by ThingAccessUtils.
CommonsLoggingOutputStream	Implements an OutputStream that will write to the given logger whenever any newline is encountered.
CommonsLoggingOutputStream.Level	A representation of the log level
ConditionalTask	A task executor that will invoke a Rule that returns a boolean indicating that another task should be run.
ConnectOptions	Encapsulates a variety of ways of opening connections to a database, from Beanshell callbacks to connection info to specifying that we should use the IIQ or Plugin DB.
ConnectOptions.ConnectOptionsBuilder	A builder for this object
ContextConnectionWrapper	Use this class instead of SailPointContext.getJdbcConnection() to work around a known glitch.
DelegatedConcurrentMap<K,V>	An interface extending DelegatedMap to implement ConcurrentMap methods.
DelegatedMap<K,V>	A Map interface that delegates all calls by default to the contained Map.
DuckWrapper	Proxy wrapper for duck typing in Java.
DummyAuthContext	Dummy authorization context for use with the authorization methods
DummyPluginResource	Creates a fake plugin context for use outside of a plugin.
DummyUriInfo	A dummy UriInfo implementation so that the BaseListResource that all plugin resources depend on doesn’t crash.
Either<L,R>	A functional programming concept that will contain either the left object or the right object, but never both.
Element	The root class of Table, Row, and Cell, which allows common functions for style, CSS class, and other common HTML elements
ErrorResponse<T>	A meta-object that can be returned by a BaseCommonPluginResource.handle(BaseCommonPluginResource.PluginAction) implementation to specify both a return object and a status in the return value.
ExpandedDate	A VO class to wrap a date in a known format, allowing clients to consume it however they wish.
Experimental	An annotation indicating that the given type is experimental.
ExportConnectionInfo	A record / vo class used to pass connection info to the export partition.
ExportFinishPartition	Finishes the export by removing the previous run record and adding the new one, with the latest export date
ExportIdentitiesPartition
ExportLinksPartition
ExportPartition	An abstract superclass for all export partitions.
ExtendedPluginContextHelper	A helper class intended to be used by anybody implementing CommonExtendedPluginConfig.
ExtendedPluginContextHelper.ConfigurationNameProvider
Failure<T,E extends Exception>	A container object holding a failure, usually used in a threaded context.
FilteringIterator<T>	Implements a Filtering Iterator that will return only items that match the Predicate.
FilteringIterator.DynamicValuePredicate<T>	A predicate that returns true if a DynamicValue or a Script returns a value that maps to Boolean true via Util.otob(Object).
FluentAccessCheck
Functions	This class implements a whole slew of java.util.function implementations, which can be used as a hack to get streams working in Beanshell.
Functions.BiFunctionWithError<A,B,R>	An extension of BiFunction that allows functional code to throw an exception.
Functions.ConnectionHandler	A generic callback for doing connection things
Functions.ConsumerWithError<T>	An extension of Consumer that allows functional code to throw an exception.
Functions.FunctionWithError<A,B>	An extension of Function that allows functional code to throw an exception.
Functions.GenericCallback	A generic callback implementation, essentially a runnable with an exception.
Functions.NullConsumer	A dual Consumer and BiConsumer that just does nothing, eating the object
Functions.OtobWrapper	Wrapper class so that Functions.otob() can be used as both a function and a predicate
Functions.PredicateWithError<A>	An extension of Predicate that allows predicate code to throw an exception.
Functions.RowHandler	A generic callback for doing result set row handling things
Functions.SupplierWithError<T>	An extension of Supplier that allows functional code to throw an exception.
GuardedCacheValue<ValueType,GuardType>	A cache value wrapper that allows access based on matching an arbitrary guard value.
HashUtilities	Utilities to return hexadecimal hashes of strings
HybridObjectMatcher	This class implements an extension to SailPoint’s most advanced matcher, the HybridReflectiveMatcher, permitting in-memory matching of arbitrary SailPointObjects.
IdentityLinkUtil	A utility class for efficiently reading various types of information from Link objects.
IdentityRefreshExecutor	Request executor to do an async refresh on a single user.
IdentityVO	A simplified VO object that can wrap an Identity and some of its useful properties.
IDWDataExporter	A partitioned task for handling data exports.
IIQObject	A meta-annotation that can be used to flag a field as an IIQ Object.
IIQObjectDeserializer	A Jackson de-serializer for an IIQ object.
IIQObjectSerializer	A Jackson serializer implementation for any object that can be serialized to XML by IIQ’s XML serializer.
Index<T>	An indexing class for associating items in a list with their index in the list
IndexingIterator<In>	An iterator that keeps track of its index, allowing you to get the current element count.
InProgress	Indicates that a class or method is currently work-in-progress.
InputDate	The JAX-RS spec requires that an input bean for QueryParam or PathParam have either a String constructor or a static valueOf(String) method.
IterateQueryOptions	The input VO for QueryUtil.iterateQuery(IterateQueryOptions), mainly to encapsulate the variety of inputs in one place.
IterateQueryOptions.IterateQueryOptionsBuilder	A builder for IterateQueryInputs objects.
LdapUtilities	Utilities for dealing with LDAP DNs and other similar concepts
Link	An object implementing the HATEOAS REST standard’s link concept
LockingObjectReference<T>	An object reference wrapped by a ReentrantLock.
LockingObjectReference.LockedObjectAction<T>	The interface to be implemented by any locked object actions
LogCapture	A class to start and stop log capture as needed.
LogLevel	Enumerates a LogLevel type, particularly for StampedMessage.
LogListener	An abstract log listener that will receive log events instead of queueing them
LogListener.LogMessage	A log message emitted if a listener is assigned to the log capture engine.
ManagedAttributeUtilities	Utilities for ManagedAttributes / entitlement objects
ManagedAttributeUtilities.BuildForm	Namespace for arguments that can be passed to ManagedAttributeUtilities.buildForm(Map, Option...).
ManagedAttributeUtilities.BuildForm.Button	A button option for forms
ManagedAttributeUtilities.BuildForm.Flags	Yes/no flags as form options
ManagedAttributeUtilities.BuildForm.Option	The interface used to cluster options that can be passed to ManagedAttributeUtilities.buildForm(Map, Option...)
MapDecodable	An interface that can be implemented by any object that would like to translate itself from a Map input.
Mappable	An interface implementing a Mappable.toMap() default method to transform any object into a Map using Jackson.
Mappable.FilterMixin	Sneaky mixin to enable this class to use its custom filter on classes that don’t support it
MapTuple	An extension of HashMap that can be produced by MapTupleBuilder.
MapTupleBuilder	A builder for MapTuple objects.
MatchUtilities	Utilities for matching objects using IIQ APIs
Maybe<T>	A functional “monad” that contains either a non-null value of the given type or an exception, but never both.
Maybe.MaybeConsumer<T>	A consumer extension that handles the Maybe concept.
Metered	Starts a Meter with the given name, then invokes the callback, then finally stops the meter before returning the output.
Metered.MeterCallback	Callback interface where no output is required
Metered.MeterCallbackWithOutput<T>	Callback interface where an output is required
MixinIgnoreType	Can be used via Jackson’s ObjectMapper.addMixInAnnotations(Class, Class) to ignore any particular type.
MockPluginContext	A mock plugin resource to use in any situation where an API requires one but your code is not running in a plugin context.
NamedParameterStatement	Named parameter prepared statement wrapper, derived from various examples around the Internet.
NoOpIntegrationExecutor	Implements a no-op integration executor, suitable for detached apps.
NoReturnValue
NullCloseableIterator<T>	An implementation of CloseableIterator that always contains no items.
NullConnector	A connector that swallows all operations quietly, used for demo and testing purposes
NullInputStream	An input stream primarily for testing purposes that always contains the given number of zeroes.
NullOutputStream	An output stream that quietly swallows the input
ObjectMapper<T>	A utility to decode a Map structure into the fields of a POJO object.
ObjectMapper.AfterMapperMethod	The method annotated with this annotation will be invoked after all mapped attributes are set.
ObjectMapper.Aliases
ObjectMapper.Convertible	Implementing this interface allows a class to coerce itself from one or more input types.
ObjectMapper.DefaultTypeNamer	Translates from a Class type to a name.
ObjectMapper.Ignore	Annotation to indicate that the given field should be ignored and not mapped.
ObjectMapper.IgnoreSuper	Indicates that the annotated class should be the stopping point for walking up the class hierarchy to find setters.
ObjectMapper.Nested	Annotation to indicate that the given element is a nested instance of the mapped class, such as an identity with a list of identities.
ObjectMapper.ObjectMapperException	The exception type thrown by all mapper methods
ObjectMapper.RawMap
ObjectMapper.SetterMethod
ObjectMapper.TypeNamer	A functional interface to translate a Class into its name.
ObjectRetriever<ItemType>	An interface allowing different implementations of object retrievers to be used with the abstract object iterator task model.
ObjectSummary	A default example implementation of an object summary VO object
OracleDBMSOutputListener	A utility to read DBMS output from an Oracle database.
Outcome	A generic class to represent (and perhaps log) some operation outcome.
OutcomeType	The various outcome types that an operation can have
PairedException	This exception is to be used whenever an exception is caught inside of a catch block.
PairedGeneralException	This exception is to be used whenever an exception is caught inside of a catch block.
Parameters	Utility class for setting the parameters on a Statement based on the input, invoking the typed setXYZ methods (e.g., setString for a string).
PlanComparators	Implements comparators to sort account requests within a provisioning plan.
PluginAuthorizationCheck	A functional interface to handle plugin REST API authorization.
PluginDataSource	A data source that delegates to a ‘real’ data source loaded from a plugin.
PluginJacksonMessageBodyReader	Message body reader that can be reused across plugins.
PluginValidationCheck	A functional interface to handle plugin validation.
PooledWorkerResults<T>	A container for holding the results of a whole pool of workers.
PrivateContextObjectConsumer<T>	A consumer interface for executing an operation on an item in a private thread
ProvisioningArguments	Configuration for the ProvisioningUtilities class
ProvisioningUtilities	Utilities to wrap the several provisioning APIs available in SailPoint.
Quad<A,B,C,D>	A group of four items
QuadFunction<A,B,C,D,R>	Represents a function that takes four inputs and produces one output
QueryTable	An extension of Table to run a SQL query and export it.
QueryUtil<T>	Simplifies querying by automatically enclosing queries in a result processing loop.
QueryUtil.ResultProcessor<U>	Callback for processing the result
Quietly	Utilities to quietly (i.e.
Ref	Constructs IIQ Reference objects using a standardized API
RemotePluginInstaller	A utility to install plugins remotely using the IIQ REST API.
RemoveNegativeRoleAssignments	A task executor for finding and removing unwanted negative role assignments.
ReportExporter
ResponsesAllowed	The annotation specifying what VO objects can be validly returned from a REST API endpoint method, apart from the defaults.
RestObject	An abstract REST object implementing the HATEOAS standard.
ResultSetIterator	An adapter that translates a ResultSet to IIQ Reporting’s preferred Iterator<Object[]>.
ResultSetIterator.ColumnOutput	The output of ResultSetIterator.extractColumnValue(ResultSet, String, Integer), containing details about the column used as well as the actual value.
ResultSetIterator.CustomTypeHandler	An interface to use for custom type handlers
RoleTargetCleanupService
Row	A class representing a row in an HTML table.
RuleWorker	A worker that runs a rule and returns its result.
RunSQLScript	A command-line entry point to run one or more SQL scripts via the internal IIQ utility that runs your SQL scripts when you install or update a plugin.
SailPointObjectCacheGenerator<T extends sailpoint.object.SailPointObject>	A cache generator to automatically pull and cache SailPoint objects
SailPointObjectDateSorter	A Comparator to sort SailPointObjects in a reliable way: first by date, and if the dates are identical, by ID.
SailpointObjectMapper<T>	An extension of ObjectMapper to handle SailPointObject types
SailpointObjectMapper.SailPointTypeNamer	Overrides the mapping from Class to class name to include the plugin cache version.
SailPointWorker	A worker thread for multi-threaded actions.
SailPointWorker.ExceptionHandler	An interface used as an error callback, specifically for use via the SailPointWorkerExecutor but potentially usable by testing code as well.
SailPointWorkerExecutor	Request executor to allow partitioning of workers across all nodes in the cluster.
Sameness	Utility methods for detecting whether two objects are the same, since IIQ is inconsistent about it.
ServiceImplementationInvoker	Functional interface to invoke the implementation of your service after doing pre-work.
ServiceUtils	Utilities for services
SingleServerService	Abstract class to easily implement a Service that will only run on the alphabetically lowest Server name.
SlicingRewritePolicy	A log rewrite policy to extract bits out of an extremely long log message.
SlicingRewritePolicy.SlicingRewriteContextConfig
SLogger	A wrapper around the Commons Logging Log class that supplements its features with some extras available in other logging libraries.
SLogger.Formatter	Helper class to format an object for logging.
SLogger.Level	An enumeration of log levels to replace the one in log4j
SmokeTestSingleServerService	A no-op implementation of the single-server service class, used for testing and demonstrations.
StampedMessage	Implements a timestamped log message similar to what would be captured by a logging framework.
StampedMessageSerializer	Custom serializer for StampedMessage outputs, to avoid having to let Jackson figure out how to serialize the Throwable object.
StyleTarget	An interface that classes can use to indicate that they can hold styles.
Syslogger	A utility for generating and committing Syslog events, even where IIQ would not produce them.
Table	Type-safe fluent API for creating HTML tables from data inputs.
TaskCallback<T,O>	A generic task callback that can be used in various contexts.
TaskUtil	Utilities for TaskDefinitions and TaskResults
TaskUtil.TaskResultConsumer	The interface used for lock-and-callback utilities
TerminatorWorker	A serializable worker to delete a single SailPoint object or a list of objects.
ThingAccessUtils	Implements the “Common Security” protocol described in the documentation.
ThreadedTaskListener<T>	An interface allowing AbstractThreadedTask jobs to communicate with their threads without exposing the entire task model.
ThreadExecutorWorker<T>	The worker for handling each input object.
ThreadWorkerCreator<T>	A functional interface for generating a SailPointWorker from a given set of objects, a consumer for those objects, and a taskContext for doing updates.
ThrowableSerializer	A custom Jackson serializer for transforming a Throwable into a standard Map format, including type, message, and stack trace.
TimestampWithTimezone	A small wrapper class for use with “Parameters” for setting a timestamp with timezone in a bulk context.
TooManyResultsException	An exception indicating that too many results were returned
TransformingIterator<In,Out>	A class that applies a transformation function to each item of an Iterator before returning it from Iterator.next().
TransformingIterator.TransformerFunction<In,Out>	A functional interface similar to Function, except throwing an exception
TriFunction<A,B,C,R>	Represents a function that takes three inputs and produces one output
Triple<A,B,C>	Extends Pair by adding one more item
TypeFriendlyConcurrentHashMap<K,V>	Basic override map class that exists entirely to include the TypeFriendlyMap default methods
TypeFriendlyDelegatedConcurrentMap<K,V>
TypeFriendlyDelegatedMap<K,V>	The TypeFriendlyDelegatedMap class combines DelegatedMap and TypeFriendlyMap in a single decorator class.
TypeFriendlyHashMap<K,V>	A minor extension to HashMap to include the TypeFriendlyMap methods
TypeFriendlyMap<K,V>	An extension to the Map interface that adds a bunch of default typed getXXX methods.
UnsupportedConnector	A connector implementation that only throws UnsupportedOperationException for all operations
Utilities	Static utility methods that are useful throughout any IIQ codebase, supplementing SailPoint’s Util in many places.
Utilities.PropertyLookupNone	Used as an indicator that the quick property lookup produced nothing.
VelocityEscapeTools	Velocity has its own ‘escape tools’ package, but it is not included with IIQ, so we made our own
VersionedCacheEntry<T>	A plugin version aware extension of CacheEntry, which will consider itself expired whenever the plugin version has changed from the version at entry creation.
VersionedCacheMap<K,V>	A variant on CacheMap intended for use in plugin-heavy environments, when you may want to clear a cache upon plugin installation or update.