Class List

Here are the classes, structs, unions and interfaces with brief descriptions:

[detail level 12345678]

▼NSummer
▼NBatch
▼NCommon
►NCollections
CAbstractPriorityQueue	Abstract Priority Queue.
CIQueue	A collection designed for holding elements prior to processing. The order in which elements are retrieved depends on the implementation.
COrderedDictionary	Dictionary that preserves the insertion order during enumeration.
COrderedSet	A set that preserves the insertion order.
CPriorityBlockingQueue	Priority Blocking Queue; inherits from AbstractPriorityQueue
CPriorityQueue
►NExtensions
CStreamExtension	Extension class for System.IO.Stream.
►NFactory
CIInitializationPostOperations	Interface to be implemented by beans that need to react once all their properties have been set by a Factory: for example, to perform custom initialization, or merely to check that all mandatory properties have been set.
►NIO
CAbstractResource	Base implementations for all concrete T:Summer.Batch.IO.IResource implementations.
CAntPathResolver	Utility class to resolve Ant style paths as resources
CFileSystemResource	Implementation of T:IResource for a file in the file system.
CIResource	Interface for a resource descriptors that abstracts from the actual type of the underlying resource
CResourceLoader	Class responsible for loading resources. Can be extended to change or expand the resolving mechanism
►NProperty
CInvalidPropertyException	Exception thrown when trying to retrieve an invalid property.
CPropertyAccessor	Utility class to access properties on an object.
►NProxy
CIProxyObject	Interface for all proxy types created by ProxyFactory. The Instance property (GetInstance) holds a reference to the underlying instance.
CProxyException	Exception thrown while creating or manipulating a proxy.
CProxyFactory	Factory for dynamic proxy. This factory can create a proxy for an interface. The created type will implement all the required interfaces as well as the IProxyObject interface. The method implementation redirect to the underlying instance. This instance can be changed and can be momentarilly be null, but it must be set when the proxy is manipulated. The created proxy supports, properties (including indexed properties), methods, and events.
CProxyObject	Implementation of IProxyObject.
►NSettings
CSettingsManager	Utility class to manage application settings
►NTaskExecution
CAsyncTaskExecutorConstants	AsyncTaskExecutor Constants.
CIAsyncTaskExecutor	Extended interface for asynchronous ITaskExecutor implementations, offering an overloaded Execute(Task, long) variant with a start timeout parameter.
CITaskExecutor	Simple task executor interface that abstracts the execution of a Task. Implementations can use all sorts of different execution strategies, such as: synchronous, asynchronous, using a thread pool, and more.
CSimpleAsyncTaskExecutor	ITaskExecutor asynchronous implementation. Supports limiting concurrent threads through the "concurrencyLimit" bean property. By default, the number of concurrent threads is unlimited. NOTE: This implementation does not reuse threads! Consider a thread-pooling TaskExecutor implementation instead, in particular for executing a large number of short-lived tasks
CSyncTaskExecutor	Synchronous task executor.
CTaskRejectedException	Exception to be thrown when a task has been rejected.
CTaskTimeoutException	Exception thrown when a IAsyncTaskExecutor rejects to accept a given task for execution because of the specified timeout.
►NTransaction
►NSupport
CITransactionSynchronization	Interface for transaction completion callbacks. An instance can be register with the T:Summer.Batch.TransactionTransactionScopeManager, it then will be called after a transaction completion.
CConnectionUtil	Utility class for connections. It holds a connection for a given connection string on a thread.
CTransactionScopeManager	Utility class for managing transaction scopes.
►NUtil
►NAtomicTypes
CAtomicInteger	An int value that may be updated atomically. An AtomicInteger is used in applications such as atomically incremented counters, and cannot be used as a replacement for an int
CIAtomic	Provide atomic access to an instance of T .
CAssert	Static Assert Helper.
CAttributeAccessorSupport	Support class for AttributeAccessors, providing a base implementation of all methods. To be extended by subclasses.
CConcurrencyThrottleSupport	Support class for throttling concurrent access to a specific resource. Designed for use as a base class, with the subclass invoking BeforeAccess and AfterAccess methods at appropriate points of its workflow. Note that AfterAccess should usually be called in a finally block! The default concurrency limit of this support class is -1 ("unbounded concurrency"). Subclasses may override this default; check the javadoc of the concrete class that you're using.
CCopyUtils	Copy Helper.
CDefaultPropertiesPersister	Default implementation of the IPropertiesPersister interface. Follows the standard key=value parsing.
CDictionaryUtils	Dictionary Helper.
CIAttributeAccessor	Interface defining a generic contract for attaching and accessing metadata to/from arbitrary objects.
CIFactory	Base interface for factories.
CIPropertiesPersister	Strategy interface for persisting a NameValueCollection, allowing for pluggable parsing strategies
CObjectUtils	Class containing utility methods on objects.
COrder	Order metadata attribute. see T:Summer.Batch.CoreTests.Core.Listener.OrderedCompositeTest for an example of Order usage : [Order(order)] order being an int Lowest orders come first.
COrderComparer	Comparer based on Order.
COrderHelper	Order Helper; needed to check for Attribute being set.
CRegexUtils	Regular Expressions Helper.
CSerializationUtils	Serialization helper.
CStringConverter	Utility class to convert a string.
CStringUtils	Class providing utility methods on character strings.
CThreadUtils	Thread Helper.
▼NCore
►NConfiguration
►NSupport
CJobFactoryRegistrationListener	Generic service that can bind and unbind an IJobFactory in an IJobRegistry.
CMapJobRegistry	Simple, thread-safe, dictionary-based implementation of IJobRegistry.
CMapStepRegistry	Simple dictionary-based implementation of IStepRegistry. Access to the dictionary is synchronized, guarded by an internal lock.
CReferenceJobFactory	Implementation of IJobFactory that just keeps a reference to an IJob without modifying it.
CDuplicateJobException	Exception that indicates a name clash when registering job instances.
CIJobFactory	Interface for a factory that creates an instance of IJob.
CIJobLocator	A runtime service locator interface for retrieving job configurations by name.
CIJobRegistry	A runtime service registry interface for registering job configurations by name.
CIListableJobLocator	A listable extension of IJobLocator.
CIStepRegistry	Registry keeping track of all the IStep defined in an IJob.
►NConverter
CDefaultJobParametersConverter	Converter for JobParameters instances using a simple naming convention for property keys. Key names that are prefixed with a '-' are considered non-identifying and will not contribute to the identity of a JobInstance. Key names ending with "<type>" where type is one of string, date, long are converted to the corresponding type. The default type is string. E.g
CIJobParametersConverter	A factory for JobParameters instances. A job can be executed with many possible runtime parameters, which identify the instance of the job. This converter allows job parameters to be converted to and from Properties.
►NExplore
►NSupport
CAbstractJobExplorerFactory	An Summer.Batch.Common.Util.IFactory<T> that automates the creation of a SimpleJobExplorer. Declares abstract methods for providing DAO object implementations.
CDbJobExplorerFactory	An Summer.Batch.Common.Util.IFactory<T> that automates the creation of a SimpleJobExplorer using Database DAO implementations. Requires the user to describe what kind of database they are using.
CLocalDataFieldMaxValueIncrementer	Local IDataFieldMaxValueIncrementer implementation. Since it is not supported here, a NotSupportedException will be thrown by the NextLong method.
CMapJobExplorerFactory	An Summer.Batch.Common.Util.IFactory<T> that automates the creation of a SimpleJobExplorer using in-memory DAO implementations.
CSimpleJobExplorer	Implementation of IJobExplorer using the injected DAOs.
CIJobExplorer	Entry point for browsing executions of running or historical jobs and steps. Since the data may be re-hydrated from persistent storage, it may not contain volatile fields that would have been present when the execution was active.
►NJob
►NBuilder
►CFlowBuilder	A builder for a flow of steps that can be executed as a job or as part of a job. Steps can be linked together with conditional transitions that depend on the exit status of the previous step.
CSplitBuilder	A builder for building a split state.
CTransitionBuilder	A builder for transitions within a flow.
CFlowBuilderException	Utility exception thrown by builders when they encounter unexpected exceptions.
CFlowJobBuilder	A job builder for FlowJob instances. A flow job delegates processing to a nested flow composed of steps and conditional transitions between steps.
CJobBuilder	Convenient entry point for building jobs of various kinds.
CJobBuilderException	Utility exception thrown by builders when they encounter unexpected exceptions.
►CJobBuilderHelper	A base class and utility for other job builders providing access to common properties like job repository.
CCommonJobProperties	common job properties.
CJobFlowBuilder	Job Flow builder.
CSimpleJobBuilder	Simple job builder.
►NFlow
►NSupport
►NState
CAbstractState	Abstract State. Base class to implement the IState interface.
CEndState	IState implementation for ending a job if it is in progress and continuing if just starting.
CFlowState	State that delegates to an IFlow.
CIFlowExecutionAggregator	Strategy interface for aggregating FlowExecution instances into a single exit status.
CMaxValueFlowExecutionAggregator	Implementation of the IFlowExecutionAggregator interface that aggregates FlowExecutionStatus, using the status with the high precedence as the aggregate status. See FlowExecutionStatus for details on status precedence.
CSplitState	A IState implementation that splits an IFlow into multiple parallel subflows.
CStepState	IState implementation that delegates to an IFlowExecutor to execute the specified Step.
CDefaultStateTransitionComparer	Sorts by decreasing specificity of pattern, based on just counting wildcards (with * taking precedence over ?). If wildcard counts are equal then falls back to alphabetic comparison. Hence * > foo* > ??? > fo? > foo.
CSimpleFlow	An IFlow that branches conditionally depending on the exit status of the last IState. The input parameters are the state transitions (in no particular order). The start state name can be specified explicitly (and must exist in the set of transitions), or computed from the existing transitions, if unambiguous.
CStateTransition	Value object representing a potential transition from one IState to another. The originating IState name and the next IState to execute are linked by a pattern for the ExitStatus::ExitCode exit code of an execution of the originating IState.
CFlowExecution	Represents a flow execution.
CFlowExecutionException	Exception used when an issue with the flow execution occurs. see Summer.Batch.Core.Job.Flow.Support.SimpleFlow for typical usages.
CFlowExecutionStatus	Represents the status of FlowExecution.
CFlowJob	Implementation of the IJob interface that allows for complex flows of steps, rather than requiring sequential execution. In general, this job implementation was designed to be used behind a parser, allowing for a namespace to abstract away details.
CFlowStep	An IStep implementation that delegates to an IFlow. Useful for logical grouping of steps, and especially for partitioning with multiple steps per execution. If the flow has steps then when the FlowStep executes, all steps including the parent FlowStep will have executions in the Summer.Batch.Core.Repository.IJobRepository (one for the parent and one each for the flow steps).
CIFlow	Interface to be implemented by flows.
CIFlowExecutor	Context and execution strategy for FlowJob to allow it to delegate its execution step by step.
CIFlowHolder	Convenient interface for components that contain nested flows.
CIJobExecutionDecider	Interface allowing for programmatic access to the decision on what the status of a flow should be. For example, if some condition that's stored in the database indicates that the job should stop for a manual check, a decider implementation could check that value to determine the status of the flow.
CIState	Interface to be implemented by flow state.
CJobFlowExecutor	Implementation of IFlowExecutor for use in components that need to execute a flow related to a JobExecution.
CAbstractJob	Abstract implementation of the IJob interface. Common dependencies such as a IJobRepository, IJobExecutionListener's, and various configuration parameters are set here. Therefore, common error handling and listener calling activities are abstracted away from implementations.
CCompositeJobParametersValidator	Composite IJobParametersValidator that passes the job parameters through a sequence of IJobParametersValidator's
CDefaultJobParametersValidator	Default implementation of IJobParametersValidator.
CIStepHandler	Strategy interface for handling an IStep on behalf of a IJob.
CSimpleJob	Simple implementation of IJob interface providing the ability to run a JobExecution. Sequentially executes a job by iterating through its list of steps. Any Step that fails will fail the job. The job is considered complete when all steps have been executed.
CSimpleStepHandler	Implementation of IStepHandler that manages repository and restart concerns.
►NLaunch
►NSupport
CExitCodeMapperConstants	ExitCodeMapper Constants.
CIExitCodeMapper	This interface should be implemented when an environment calling the batch framework has specific requirements regarding the operating system process return status.
CISystemExiter	Interface for exiting the VM.
CRunIdIncrementer	Helper class for id incrementation on job parameters.
CSimpleJobLauncher	Simple implementation of the IJobLauncher interface. The ITaskExecutor interface is used to launch a Job. This means that the type of executor set is very important. If a SyncTaskExecutor is used, then the job will be processed within the same thread that called the launcher. Care should be taken to ensure any users of this class understand fully whether or not the implementation of TaskExecutor used will start tasks synchronously or asynchronously. The default setting uses a synchronous task executor
CSimpleJobOperator	Simple implementation of the IJobOperator interface. Due to the amount of functionality the implementation is combining, the following dependencies are required:
CSimpleVmExitCodeMapper	An implementation of IExitCodeMapper that can be configured through a dictioanry from batch exit codes (string) to integer results. Some default entries are set up to recognise common cases. Any that are injected are added to these.
CVmSystemExiter	Implementation of the ISystemExiter interface that calls the standards Environment.Exit method. It should be noted that there will be no unit tests for this class, since there is only one line of actual code, that would only be testable by mocking System or Runtime.
CBatchRuntime	Factory that builds instances of IJobOperator.
CIJobLauncher	Simple interface for controlling jobs, including possible ad-hoc executions, based on different runtime identifiers. It is extremely important to note that this interface makes absolutely no guarantees about whether or not calls to it are executed synchronously or asynchronously. The docs for specific implementations should be checked to ensure callers fully understand how the job will be run.
CIJobOperator	Low level interface for inspecting and controlling jobs with access only to primitive and collection types. Suitable for a command-line client (e.g. that launches a new process for each operation), or a remote launcher.
CJobExecutionNotFailedException	Exception to indicate that user asked for a job execution to be resumed when actually it didn't fail.
CJobExecutionNotRunningException	Execution indicating that a JobExecution that is not currently running has been requested to stop.
CJobExecutionNotStoppedException	Exception to indicate that user asked for a job execution to be aborted when hasn't been stopped.
CJobInstanceAlreadyExistsException	Exception to indicate that a required Job is not available.
CJobParametersNotFoundException	Exception to indicate that a required IJobParametersIncrementer is not available.
CNoSuchJobException	Exception to indicate that a required IJob is not available.
CNoSuchJobExecutionException	Exception to indicate that a required JobExecution is not available.
CNoSuchJobInstanceException	Exception that signals that the user requested an operation on a non-existent JobInstance.
►NListener
CCompositeJobExecutionListener	Convenient job execution listener implemented through composite pattern.
CCompositeStepExecutionListener	Convenient step execution listener implemented through composite pattern.
CIListenerMetaData	A common interface for listener meta data enumerations No support for attributes.
COrderedComposite	Ordered Composite : Composite pattern used on items that need to hold an order metadata information. Relies on System.Attribute Order being put on classes / interfaces (see Order / OrderHelper / OrderComparer in Util NS)
CStepExecutionListenerSupport	Basic IStepExecutionListener Support
►NPartition
►NSupport
CAbstractPartitionHandler	Base IPartitionHandler implementation providing common base features. Subclasses are expected to implement only the DoHandle method which returns with the result of the execution(s) or an exception if the step failed to process.
CDefaultStepExecutionAggregator	Default implementation of IStepExecutionAggregator.
CIPartitioner	Central strategy interface for creating input parameters for a partitioned step in the form of ExecutionContext instances. The usual aim is to create a set of distinct input values, e.g. a set of non-overlapping primary key ranges, or a set of unique filenames.
CIPartitionNameProvider	Optional interface for IPartitioner implementations that need to use a custom naming scheme for partitions. It is not necessary to implement this interface if a partitioner uses the default partition names
CIStepExecutionAggregator	Strategy for a aggregating step executions, usually when they are the result of partitioned or remote execution.
CMultiResourcePartitioner	Implementation of IPartitioner that locates multiple resources and associates their absolute URIs in the execution contexts. Create one execution context per resource, whatever the grid size.
CPartitionStep	Implementation of IStep which partitions the execution and spreads the load using an IPartitionHandler.
CSimpleStepExecutionSplitter	Generic implementation of IStepExecutionSplitter that delegates to a IPartitioner to generate ExecutionContext instances. Takes care of restartability and identifying the step executions from previous runs of the same job. The generated StepExecution instances have names that identify them uniquely in the partition. The name is constructed from a base (name of the target step) plus a suffix taken from the IPartitioner identifiers, separated by a colon, e.g
CTaskExecutorPartitionHandler	An IPartitionHandler that uses an ITaskExecutor to execute the partitioned IStep locally in multiple threads. This can be an effective approach for scaling batch steps that are IO intensive, like directory and filesystem scanning and copying. By default, the thread pool is synchronous.
CIPartitionHandler	Interface defining the responsibilities of controlling the execution of a partitioned StepExecution. Implementations will need to create a partition with the IStepExecutionSplitter, and then use an execution fabric (grid, etc.), to execute the partitioned step. The results of the executions can be returned raw from remote workers to be aggregated by the caller.
CIStepExecutionSplitter	Strategy interface for generating input contexts for a partitioned step execution independent from the fabric they are going to run on.
►NRepository
►NDao
CAbstractDbBatchMetadataDao	Abstract super class for database implementations of the DAOs.
CContextKey	ContextKey Inner class.
CContextKeyExtension	ContextKey class extension.
CDbExecutionContextDao	Database DAO for ExecutionContext Stores execution context data related to both Step and Job using a different table for each.
CDbJobExecutionDao	Database implementation of IJobExecutionDao. Uses sequences (via IDataFieldMaxValueIncrementer abstraction) to create all primary keys before inserting a new row. Objects are checked to ensure all mandatory fields to be stored are not null. If any are found to be null, an ArgumentException will be thrown.
CDbJobInstanceDao	Database implementation of IJobInstanceDao. Uses sequences (via IDataFieldMaxValueIncrementer abstraction) to create all primary keys before inserting a new row. Objects are checked to ensure all mandatory fields to be stored are not null. If any are found to be null, an ArgumentException will be thrown.
CDbStepExecutionDao	Database implementation of IStepExecutionDao. Allows customization of the tables names used for step meta data via a prefix property. Uses sequences or tables (via IDataFieldMaxValueIncrementer abstraction) to create all primary keys before inserting a new row. All objects are checked to ensure all fields to be stored are not null. If any are found to be null, an ArgumentException will be thrown.
CIExecutionContextDao	Data Access Object for execution contexts.
CIJobExecutionDao	Data Access Object for job executions.
CIJobInstanceDao	Data Access Object for job instances.
CIStepExecutionDao	Data Access Object for step executions.
CMapExecutionContextDao	In-memory implementation of IExecutionContextDao backed by dictionaries.
CMapJobExecutionDao	In-memory implementation of IJobExecutionDao.
CMapJobInstanceDao	In-memory implementation of IJobInstanceDao.
CMapStepExecutionDao	In-memory implementation of IStepExecutionDao.
►NSupport
CAbstractJobRepositoryFactory	A Factory that automates the creation of a SimpleJobRepository. Declares abstract methods for providing DAO object implementations.
CDbJobRepositoryFactory	A Factory that automates the creation of a SimpleJobRepository using ODBC DAO implementations which persist batch metadata in database. Requires the user to describe what kind of database they are using.
CMapJobRepositoryFactory	A FactoryBean that automates the creation of a SimpleJobRepository using non-persistent in-memory DAO implementations. This repository is only really intended for use in testing and rapid prototyping. Not suited for use in multi-threaded jobs with splits, although it should be safe to use in a multi-threaded step
CSimpleJobRepository	Implementation of IJobRepository that stores JobInstances, JobExecutions, and StepExecutions using the injected DAOs.
CIExecutionContextSerializer	A composite interface that combines both serialization and deserialization of an execution context into a single implementation. Implementations of this interface are used to serialize the execution context for persistence during the execution of a job.
CIJobRepository	Repository responsible for persistence of batch meta-data entities.
CJobExecutionAlreadyRunningException	JobExecutionAlreadyRunningException
CJobInstanceAlreadyCompleteException	An exception indicating an illegal attempt to restart a job that was already completed successfully.
CJobRestartException	An exception indicating an illegal attempt to restart a job.
►NScope
►NContext
CChunkContext	Context object for weakly typed data stored for the duration of a chunk (usually a group of items processed together in a transaction). If there is a rollback and the chunk is retried the same context will be associated with it.
CJobContext	A context object that can be used to interrogate the current JobExecution and some of its associated properties using expressions based on bean paths. Has public getters for the job execution and convenience methods for accessing commonly used properties like the ExecutionContext associated with the job execution.
CJobSynchronizationManager	Central convenience class for framework use in managing the job scope context. Generally only to be used by implementations of Job. N.B. it is the responsibility of every Job implementation to ensure that a JobContext is available on every thread that might be involved in a job execution, including worker threads from a pool.
CStepContext	A context object that can be used to interrogate the current StepExecution and some of its associated properties using expressions based on bean paths. Has public getters for the step execution and convenience methods for accessing commonly used properties like the ExecutionContext associated with the step or its enclosing job execution.
CStepContextRepeatCallback	Convenient base class for clients who need to do something in a repeat callback inside a IStep.
CStepSynchronizationManager	Central convenience class for framework use in managing the step scope context. Generally only to be used by implementations of IStep. N.B. : it is the responsibility of every IStep implementation to ensure that a StepContext is available on every thread that might be involved in a step execution, including worker threads from a pool.
CSynchronizationManagerSupport	Central convenience class for framework use in managing the scope context.
CStepScopeProxyObject	Implementation of IProxyObject for step scope. The instance is retrieved using StepScopeSynchronization.GetInstance.
CStepScopeSynchronization	Static class that keeps track of the dependencies in the step scope and synchronizes the proxies.
►NStep
►NBuilder
CAbstractStepBuilder	Base class for all step builders. Holds the common attributes to all steps.
CAbstractTaskletStepBuilder	Base class for tasklet based step builders.
CPartitionStepBuilder	Step builder for partition steps.
CSimpleStepBuilder	Step builder for step with reader, processor, and writer.
CTaskletStepBuilder	Step builder for steps with custom tasklet.
►NItem
CChunk	Encapsulation of a list of items to be processed and possibly a list of failed items to be skipped. To mark an item as skipped clients should iterate over the chunk , and if there is a failure call Remove() on the items list. The skipped items are then available through the chunk.
CChunkOrientedTasklet	An ITasklet implementing variations on read-process-write item handling.
CIChunkProcessor	Interface defined for processing Chunks.
CIChunkProvider	Interface for providing Chunks to be processed, used by the T:ChunkOrientedTasklet.
CSimpleChunkProcessor	Simple implementation of the T:IChunkProcessorinterface that handles basic item writing and processing. Any exceptions encountered will be rethrown.
CSimpleChunkProvider	Simple implementation of the T:IChunkProvider interface that does basic chunk providing from an T:Summer.Batch.Infrastructure.Item.IItemReader.
►NJob
CDefaultJobParametersExtractor	Simple implementation of IJobParametersExtractor which pulls parameters with named keys out of the step execution context and the job parameters of the surrounding job.
CIJobParametersExtractor	Strategy interface for translating a StepExecutioninto JobParameters.
CJobStep	An IStep that delegates to a Job to do its work. This is a great tool for managing dependencies between jobs, and also to modularise complex step logic into something that is testable in isolation. The job is executed with parameters that can be extracted from the step execution, hence this step can also be usefully used as the worker in a parallel or partitioned execution.
►NTasklet
CIPowerShellExitCodeMapper	Maps the exit code of a PowerShell to ExitStatus value returned by a PowerShell. Designed for use with the PowerShellTasklet
CIStoppableTasklet	An extension to the ITaskletinterface to allow users to add logic for stopping a tasklet. It is up to each implementation as to how the stop will behave. The only guarantee provided by the framework is that a call to JobOperator.Stop(long) will attempt to call the stop method on any currently running IStoppableTasklet. The call to IStoppableTasklet.Stop() will be from a thread other than the thread executing Tasklet.Execute() so the appropriate thread safety and visibility controls should be put in place.
CISystemProcessExitCodeMapper	Maps the exit code of a system process to ExitStatus value returned by a system command. Designed for use with the SystemCommandTasklet.
CITasklet	Strategy for processing in a step.
CPowerShellExitCodeMapper	Simple ISystemProcessExitCodeMapper implementation that performs following mapping: 0 -> ExitStatus.Completed else -> ExitStatus.Failed
CPowerShellTasklet	An ITasklet that runs a powershell script. The script is executed asynchronously using injected ITaskExecutor - timeout value is required to be set, so that the batch job does not hang forever if the external process hangs. Tasklet periodically checks for termination status (i.e. Script finished its execution or timeout expired or job was interrupted). The check interval is given by TerminationCheckInterval. When job interrupt is detected tasklet's execution is terminated immediately by throwing JobInterruptedException
CSimpleSystemProcessExitCodeMapper	Simple ISystemProcessExitCodeMapper implementation that performs following mapping: 0 -> ExitStatus.Completed else -> ExitStatus.Failed
CSystemCommandException	Exception indicating failed execution of system command.
CSystemCommandTasklet	see cref="ITasklet"/>that executes a system command. The system command is executed asynchronously using injected ITaskExecutor - timeout value is required to be set, so that the batch job does not hang forever if the external process hangs. Tasklet periodically checks for termination status (i.e. Command finished its execution or timeout expired or job was interrupted). The check interval is given by TerminationCheckInterval. When job interrupt is detected tasklet's execution is terminated immediately by throwing JobInterruptedException
CTaskletStep	Simple implementation of executing the step as a call to a ITasklet, possibly repeated, and each call surrounded by a transaction. The structure is therefore that of a loop with transaction boundary inside the loop. The loop is controlled by the step operations (StepOperations=RepeatOperations))
CAbstractStep	An IStepimplementation that provides common behavior to subclasses, including registering and calling listeners.
CFatalStepExecutionException	Used to wrap fatal exceptions that may occur during step execution.
CIStepHolder	Interface for holders of a IStep as a convenience for callers who need access to the underlying instance.
CIStepInterruptionPolicy	Strategy interface for an interruption policy. This policy allows IStepimplementations to check if a job has been interrupted.
CIStepLocator	Interface for locating a Step instance by name.
CNoSuchStepException	Exception to signal that a step was requested that is unknown or does not exist.
CThreadStepInterruptionPolicy	Policy that checks the current thread to see if it has been interrupted.
►NUnity
►NInjection
CConcatenationNode	A node representing the concatenation of different strings.
CExpressionNode	Abstract class for nodes representing a late binding expression.
CIdentifierNode	A node representing an identifier.
CIndexAccessorNode	A node representing an index access.
CJobContextDependencyResolverPolicy	Dependency resolver that reads a property from the job context.
CJobContextValue	Implementation of InjectionParameterValue that reads a property from the job context.
►CLateBindingConfigurationParser	Parser for late binding expressions.
CLateBindingParserException	Exception thrown when an error is encountered while parsing a late binding configuration.
CLateBindingInjectionValue	Implementation of InjectionParameterValue for late binding expressions.
CLateBindingNode	Base class for all the nodes of an AST representing a late binding configuration.
CLiteralValueDependencyResolverPolicy	Implementation of IDependencyResolverPolicy that converts a string to the specified type using StringConverter.
CPosition	Represents the position of a node in the configuration.
CResourceDependencyResolverPolicy	Implementation of IDependencyResolverPolicy that resolves a URI to an IResource.
CResourceInjectionValue	Implementation of TypedInjectionValue that resolves a URI to an IResource.
CSettingsDependencyResolverPolicy	Dependency resolver that reads a property from the settings.
CStepContextDependencyResolverPolicy	Dependency resolver that reads a property from the step context.
CStepContextValue	Implementation of InjectionParameterValue that reads a property from the step context.
CStringConcatenationResolverPolicy	Implementation of IDependencyResolverPolicy that concats strings that are evaluated at runtime. Values can be of type IDependencyResolverPolicy, Lazy<T>, or Func<T>. Values of other type are converted to string.
CStringNode	A node representing a string literal.
►NSingleton
CSingletonExtension	Unity extension to change the default lifetime manager to ContainerControlledLifetimeManager.
CSingletonStrategy	Unity builder strategy that changes the default lifetime manager to ContainerControlledLifetimeManager. It needs to be executed before LifetimeStrategy, and thus should be registered with the Microsoft.Practices.Unity.ObjectBuilder.UnityBuildStage.TypeMapping stage.
►NStepScope
CStepScopeDependency	Represents a dependency in the scope step.
CStepScopeExtension	Unity extension to handle the step scope. It adds the StepScopeStrategy at the UnityBuildStage.PreCreation stage and registers to the ExtensionContext.Registering event to synchronize registration of dependencies in the step scope with StepScopeSynchronization.
CStepScopeLifetimeManager	Implementation of LifetimeManager for step scope. It relies on StepSynchronizationManager to store and retrieve the instance.
CStepScopeOverride	Implementation of ResolverOverride that overrides dependencies in the step scope.
CStepScopeResolverPolicy	A dependency resolver used when resolving dependencies in the step scope for an instance that is not in the step scope itself. It creates a proxy object, the underlying instance of which will be updated at the start of each step.
CStepScopeStrategy	Builder strategy for step scope. It should be added at the UnityBuildStage.PreCreation stage. Before the instance is created, it checks resolvers for the constructor parameters, properties, and method parameters. If any dependency is in the step scope but the current instance being built is not, the resolver is overriden using StepScopeOverride.
►NXml
CIXmlStepContainer	Interface to mark xml steps container (job & flow)
CXmlBatchlet	Xml representation of a batchlet.
CXmlChunk	Xml representation of chunk.
CXmlEnd	Xml representation of end
CXmlFail	Xml representation of fail.
CXmlFlow	Xml representation of flow.
CXmlItemProcessor	Xml representation of item processor.
CXmlItemReader	Xml reprensentation of item reader.
CXmlItemWriter	Xml representation of item writer.
CXmlJob	Xml representation of job.
CXmlJobElement	Xml representation of a job element.
CXmlJobParser	Parser for the batch xml configuration.
CXmlListener	Xml representation of listener
CXmlListeners	Xml representation of listeners
CXmlNext	Xml representation of next.
CXmlPartition	Xml representation of partition.
CXmlPartitionMapper	Xml representation of PartitionMapper
CXmlSplit	Xml representation of split.
CXmlStep	Xml representation of step.
CXmlTransitionElement	Xml representation of transition element.
CJobRegistrationHandler	Class to handle the registration of jobs. Xml parsing of the configuration must be have been done prior to invoking methods from this class.
CPostOperationsStrategy	the BuilderStrategy used for this extension.
CPostprocessingUnityExtension	Extension to unity container, to handle post-initializations operations
CReference	Structure that represent a reference.
CRegistration	Registration
CRegistrationException	Exception thrown when there are errors in the Unity configuration of the batch.
CRegistrationExtension	Extension for easier use of Registration<TFrom,TTo>.
CStepLoader	Loads a step from an XML definition and a Unity _container.
CUnityExtensions	Extensions methods for Unity.
CUnityLoader	Class that registers job artifacts in a unity container. It will load a default configuration for the main job architecture, then parse a job xml file if supplied
CBatchStatus	Statuses of a batch execution.
CDefaultJobKeyGenerator	Default implementation of the IJobKeyGenerator<JobParameters> interface.
CEntity	Batch Domain Entity class. Any class that should be uniquely identifiable from another should subclass from Entity. More information on this pattern and the difference between Entities and Value Objects can be found in Domain Driven Design by Eric Evans.
CExitStatus	Value object used to carry information about the status of a job or step execution. ExitStatus is immutable and therefore thread-safe.
CIJob	A Job's contract.
CIJobExecutionListener	Provide callbacks at specific points in the lifecycle of an IJob. Implementations can be stateful if they are careful to either ensure thread safety, or to use one instance of a listener per job, assuming that job instances themselves are not used by more than one thread.
CIJobKeyGenerator	Strategy interface for the generation of the key used in identifying unique JobInstance .
CIJobParametersIncrementer	Interface for obtaining the next JobParameters in a sequence.
CIJobParametersValidator	Strategy interface for an IJobto use in validating its parameters for an execution.
CIStep	Batch domain interface representing the configuration of a step. As with the Job, an IStep is meant to explicitly represent the configuration of a step by a developer, but also the ability to execute the step.
CIStepExecutionListener	Listener interface for the lifecycle of an IStep.
CIStepListener	Marker interface that acts as a parent to all step domain listeners, such as IStepExecutionListener.
CJobExecution	Batch domain object representing the execution of a job.
CJobExecutionException	Root of exception hierarchy for checked exceptions in job and step execution. Clients of the Job should expect to have to catch and deal with these exceptions because they signal a user error, or an inconsistent state between the user's instructions and the data.
CJobInstance	Batch domain object representing a uniquely identifiable job run. JobInstance can be restarted multiple times in case of execution failure and it's lifecycle ends with first successful execution
CJobInterruptedException	Exception to indicate the the job has been interrupted. The exception state indicated is not normally recoverable by batch application clients, but internally it is useful to force a check. The exception will often be wrapped in a runtime exception (usually UnexpectedJobExecutionException before reaching the client.
CJobParameter	Domain representation of a parameter to a batch job. Only the following types can be parameters: String, Long, Date, and Double. The identifying flag is used to indicate if the parameter is to be used as part of the identification of a job instance. as org.springframework.batch.core.JobParameter
CJobParameters	Value object representing runtime parameters to a batch job. Because the parameters have no individual meaning outside of the JobParameters they are contained within, it is a value object rather than an entity. It is also extremely important that a parameters object can be reliably compared to another for equality, in order to determine if one JobParameters object equals another. Furthermore, because these parameters will need to be persisted, it is vital that the types added are restricted. This class is immutable and therefore thread-safe.
CJobParametersBuilder	Helper class for creating JobParameters. Useful because all JobParameter objects are immutable, and must be instantiated separately to ensure typesafety. Once created, it can be used in the same was a StringBuilder (except, order is irrelevant), by adding various parameter types and creating a valid JobParameters once finished. Using the identifying flag indicates if the parameter will be used in the identification of a JobInstance. That flag defaults to true.
CJobParametersInvalidException	Exception for Job to signal that some JobParameters are invalid.
CJobStarter	Job starter. Used to start or re-start jobs
CStartLimitExceededException	Indicates the step's start limit has been exceeded.
CStepConstants	IStep constants.
CStepContribution	Represents a contribution to a StepExecution, buffering changes until they can be applied at a chunk boundary.
CStepExecution	Batch domain object representation the execution of a step. Unlike JobExecution, there are additional properties related the processing of items such as commit count, etc.
CStepListenerConstant	Constant holder for IStepListener interface.
CUnexpectedJobExecutionException	Indicates to the framework that a critical error has occurred and processing should immediately stop.
▼NData
►NIncrementer
CAbstractColumnMaxValueIncrementer	Base class for IDataFieldMaxValueIncrementer that use a column in a custom sequence table.
CAbstractDataFieldMaxValueIncrementer	Base class for IDataFieldMaxValueIncrementer that holds general information such as the connection string or the provider factory.
CAbstractSequenceMaxValueIncrementer	Abstract class for sequence maximum value incrementer.
CDb2SequenceMaxValueIncrementer	Sequence maximum value incrementer for the db2 database.
CIDataFieldMaxValueIncrementer	Interface that defines contract of incrementing any data store field's maximum value. Works much like a sequence number generator. Typical implementations may use standard SQL, native RDBMS sequences or Stored Procedures to do the job.
COracleSequenceMaxValueIncrementer	Sequence maximum value incrementer for the oracle database.
CSqlServerIncrementer	Column maximum value incrementer for the sql server database.
►NParameter
CDictionaryParameterSource	A IQueryParameterSource based on a dictionary.
CIPlaceholderGetter	An interface for getting placeholder for SQL queries.
CIQueryParameterSource	Interface for classes that provide values to SQL queries.
CIQueryParameterSourceProvider	Interface in charge of providing IQueryParameterSource for items.
CParameterExtension	Class providing and extension to facilitate adding parameters to command.
CPlaceholderGetter	Default implementation of IPlaceholderGetter.
CPropertyParameterSource	Implementation of IQueryParameterSource that retrieves parameter values by reading the properties of an object. The property lookup is case insensitive.
CPropertyParameterSourceProvider	Implementation of T:IQueryParameterSourceProvider that creates a new PropertyParameterSource for each item.
CConnectionProvider	Implementation of IConnectionProvider that relies on ConnectionUtil to manager connections.
CConverter	Utility class for converting data to unify the type of the values read from the database providers.
CDatabaseExtensionManager	Static class to manage support to different databases.
CDataRecordWrapper	Utility class to handle data conversion from a IDataRecord.
CDb2Extension	Extension for DB2 support (provider name "IBM.Data.DB2").
CDbOperator	Dedicated database operations. Most services that need to interact with a database should be using the methods exposed by this operator.
CIConnectionProvider	Interface to provide a connection. The Connection property is expected to return an open connection, but implementatons have complete control over the lifetime of the connection.
CIDatabaseExtension	Interface to add support for a database. Implementations should have a parameter-less constructor so they can be automatically registered by DatabaseExtensionManager.
COracleExtension	Extension for Oracle support.
►CParsedQuery	A class for parsing parameters of an SQL query. Parameters are expected to be named and have '@' or ':' as a prefix. The specified IPlaceholderGetter is used to replace the parameters in the substituted query.
CPosition	A simple struct to hold parameter position.
CSqlServerExtension	Extension for SQL Server support (provider name "System.Data.SqlClient").
▼NExtra
►NCopybook
CCopybookElement	Xml representation of a Copybook Element
CCopybookLoader	Static utility class to load copybooks
CFieldFormat	Xml representation of FieldFormat
CFieldsGroup	Xml representation of FieldsGroup.
CFileFormat	Xml representation of FileFormat.
CIFieldsList	Interface to represent a list of Fields.
CRecordFormat	Xml representation of RecordFormat.
CRecordFormatMap	Map of record format.
►NDelegating
CDelegatingBufferingItemReader	This class delegates reading to the inner reader and keeps track of the next record to read, in order to know if the current one is the last one The next record to read is then buffered to be returned next time. The "last one" information is saved in the step context.
CDelegatingConditionalItemWriter	This class delegates writing to the inner writer, checking a condition through the supplied ItemCondition for each element to decide if it must be written.
CDelegatingGroupReader	This class delegates reading to the inner reader and accumulates the records while no rupture is found, using the supplied rupture definition (list of fields separated by commas).
CDelegatingListItemWriter	Writter that flattens collections into a list before delegating to an inner writer. Used when a processor returns a collection.
►NEbcdic
►NEncode
CEbcdicConstants	Class holding constants used for encoding and decoding EBCDIC
CEbcdicDecoder	Decodes EBCDIC values to their corresponding C# objects.
CEbcdicEncoder	Encode C# objects to EBCDIC
►NException
CCopybookParsingException	Exception thrown when there are errors while parsing a copybook.
CEbcdicException	Parent of all exceptions that relate to reading / writing EBCDIC files
CEndOfFileException	Exception thrown by EbcdicReader to signal that the end of file has been prematurely encountered.
CFieldParsingException	Exception is thrown by EbcdicDecoder to signal an error while trying to parse an Ebcdic field.
CUnexpectedFieldTypeException	Exception thrown by EbcdicReader and EbcdicWriter when the format of a field is missing or unknown.
CValueTypeMismatchException	Exception thrown by EbcdicEncoder when encoding a value to signal that it did not match the expected type.
CAbstractEbcdicMapper	Abstract super type for all mappers. It only contains the implementation of ToCamelCase, which is required by both reader and writer mappers.
CAbstractEbcdicReaderMapper	Abstract super type for implementation of IEbcdicReaderMapper. It holds information and code required by most mappers, like date parser.
CCompositeEbcdicReaderMapper	A mapper for reading EBCDIC files with different record formats. It must be provided with the correct mappers, and will delegate to them according to the discriminator value.
CEbcdicFileReader	A Summer.Batch reader for EBCDIC files.Given a file and a copybook it returns the records in the file. An IEbcdicReaderMapper is also required to match records to actual business objects
CEbcdicFileWriter	A Spring Batch writer for a EBCDIC files. It writes business object as EBCDIC records, according to a copybook and a mapper.
CEbcdicParseException	Exception throw by the EbcdicFileReader when there is an error reading an EBCDIC file.
CEbcdicReader	An EbcdicReader reads bytes from an input stream and returns records, according to a copybook. Each call to NextRecord returns a list of objects, containing the decoded values of the fields. When there are no more records to read, it returns null. Copybooks with multiple records are supported. The reader relies on the position get/set methods of the input stream to detect the format of the current record.
CEbcdicWriter	An EbcdicWriter writes records to an output stream, according to a copybook. Please note that this class is "Stream agnostic"
CEbcdicWriterMapper	An EbcdicWriterMapper maps an item to a list of objects that can be written as an EBCDIC record. It requires a boolean encoder and a date parser to correctly manage booleans and dates. For each, a default implementation is used if none is provided.
CICopybookIo	Interface for classes using copybooks for reading or writing EBCDIC files.
CIEbcdicBusinessObject	Represents a business object mapped on a EBCDIC record.
CIEbcdicReaderMapper	An EbcdicReaderMapper maps a list of fields, corresponding to an EBCDIC record, to a business object.
►NEmailSupport
CEmailTasklet	Tasklet for sending emails. The host, from, subject and body fields are mandatory. The body is read from a resource. At least one recipient should be specified (in to, cc, or bcc).
►NEmptyCheckSupport
CEmptyFileCheckTasklet	Simple tasklet that checks if a given file is empty. It returns "EMPTY" if the file is empty or absent, "NOT_EMPTY" if it exists and is not empty.
►NFtpSupport
CFtpGetTasklet	Custom tasklet to do some ftp get NOTE : For now, sftp is UNsupported
CFtpPutTasklet	Custom tasklet to do some ftp put Sftp is unsupported for now
►NIO
CFileUtilsTasklet	A tasklet for basic file manipulations
CGdgResourceLoader	Resource loader that supports generation data groups (GDG) with the "gdg:" URI protocol. Other URIs or paths without protocol are delegated to ResourceLoader
►NJob
CJobContextPreparer	Prepares the job context by inserting job parameters in it
►NProcess
CAbstractProcessAdapter	Common logic for managing streams in readers and writers used in a process. If the underlying reader/writer is not an ItemStream, this base class does nothing Not to be used directly, it contains only the base common logic of ProcessReaderAdapter and ProcessWriterAdapter.
CIProcessAdapter	Interface for managing streams in readers and writters used in a process
CIProcessReader	Interface for readers in a process.
CIProcessWriter	Interface for writers in process
CProcessReaderAdapter	This class allows an IItemReader to be used in a process.
CProcessWriterAdapter	This class allows an IItemWriter to be used in a process.
►NReport
CReportStep	Tasklet to perform report generation. Based on Microsoft Data Report.
►NService
►NStop
CFailedJobException	Exception thrown when a job is stopped with ServiceStop.
CServiceStop	Service use to sto stop a job or skipping a record.
CSkippedItemException	Exception thrown when a record is skipped with ServiceStop.
CAbstractService	Super class for services that need access to job and step context via context managers.
►NSort
►NComparer
CComparerChain	Implementation of IComparer<T> that chains a list of IComparer<T>s. The result of the comparison is the result of the first sub-comparers that has a result different than zero, or zero if all comparers return zero.
►NFilter
CConjunctionFilter	A filter that does the logical conjunction of several filters.
CDisjunctionFilter	A filter that does the logical disjunction of several filters.
CIFilter	Interface for selecting records. Correspond to omit or include in legacy.
CNegationFilter	Implementation of IFilter<T> that negates another filter.
►NFormat
CIFormatter	Interface for formatting records.
►NLegacy
►NAccessor
CAbstractAccessor	Base class for IAccessor<T>
CBinaryAccessor	Implementation of IAccessor<T> for binary encoded numbers.
CConstantAccessor	Implementation of IAccessor<T> that returns a constant. Set is not supported.
CIAccessor	Interface for getting and setting values in array of bytes records
CPackedAccessor	Implementation of IAccessor<T> for packed numbers.
CStringAccessor	Implementation of IAccessor<T> for string values.
CZonedAccessor	Implementation of IAccessor<T> for binary zoned numbers.
►NComparer
CAbstractBytesComparer	Base class for implementations of IComparer<T> on byte arrays.
CDefaultComparer	Default implementation of AbstractBytesComparer that relies on an IAccessor<T> to retrieve a value to compare in a byte array.
CStringComparer	Implementation of AbstractBytesComparer that compares byte arrays by extracting a string value.
►NFilter
CAbstractLegacyFilter	Abstract base class for legacy filters based on byte array records. The filter compares two values using IAccessor<T>.
CDecimalFilter	Implementation of AbstractLegacyFilter<T> for comparing decimals.
CStringFilter	Implementation of AbstractLegacyFilter<T> for comparing strings.
CSubstringFilter	Implementation of AbstractLegacyFilter<T> for substring comparison.
►NFormat
CConstantFormatter	Implementation of ISubFormatter that writes a constant.
CCopyFormatter	Implementation of ISubFormatter that copies a sub-part of the input record into the output record.
CISubFormatter	Interface used by LegacyFormatter to format a sub-part of the output record.
CLegacyFormatter	Implementation of IFormatter<T> that emulates legacy formatting. It relies on a list of ISubFormatter that each create a part of the output record.
CNumericEditFormatter	Implementation of ISubFormatter that allows formatting a number read from the input record into a string.
►NParser
CAbstractParser	Base class for parsers of legacy configuration cards.
CComparerParser	Parser for sort configuration cards that creates an IComparer<T>.
CFilterParser	Parser for include and omit configuration cards that produce instances of IFilter<T>.
CFormatterParser	Parser for "inrec" and "outrec" configuration cards that produce instances of Summer.Batch.Extra.Sort.Format.IFormatter<T>.
CLexer	Lexer for DFSORT configuration strings.
COutfilParser	Parser for outfil cards. It expects outfil configurations containing 'include', 'omit', and 'outrec' cards. Each configuration must be separated by a semi-colon.
CParsingException	Exception thrown when an error occurs while parsing a configuration card.
CSumParser	Parser for sum configuration cards that produces instances of ISum<T>.
CBlockAccessorFactory	Implementation of IRecordAccessorFactory<T> for block readers and writers.
CBlockRecordReader	Implementation of IRecordReader<T> for block records. If record length is more than zero the blocks are fixed length record, otherwise they are variable length record and a RDW (record descriptor word) should be present.
CBlockRecordWriter	Implementation of IRecordWriter<T> for block records.
CBytesExtensions	A utility class for manipulating bytes array
CBytesSum	Implementation of ISum<T> that sums number encoded in byte arrays. Numbers are read using IAccessor<T>s.
CLegacyOutputFile	Implementation of IOutputFile<T> for byte array records.
CSeparatorAccessorFactory	Implementation of IRecordAccessorFactory<T> for records separated by a specific separator.
CSeparatorRecordReader	Implementation of IRecordReader<T> for records separated by a specific separator.
CSeparatorRecordWriter	Implementation of IRecordWriter<T> for records separated by a specific separator.
►NSum
CISum	Interface for summing records.
CSkipSum	Implementation of ISum<T> that only keeps one record (which is unchanged).
CIOutputFile	Class that represents an output file and its associated options (e.g., filter, formatter).
CIRecordAccessorFactory	Factory interface for creating instances of IRecordReader<T> and IRecordWriter<T>.
CIRecordReader	Interface that abstracts a record reader.
CIRecordWriter	Interface that abstracts a record writer.
CRecordReaderBuffer	Comparable buffer for IRecordReader<T>. It is used by Sorter<T> when merging different files. The buffers are sorted using their next record.
CSorter	Sorts a collection of files. Files are read as records using a IRecordReader<T>. Records can be filtered using Filter. InputFormatter allows to format the records before they are sorted. If Comparer is not set, records are copied in the order they are read, but they are still filtered or formatted.
CSortException	Exception thrown when there are problems in a sort step. More specific sort exceptions should inherit from it.
CSortTasklet	A tasklet that sorts files. Uses legacy sort cards.
CSumWriter	Implementation of a IRecordWriter<T> that can sum similar records using a ISum<T>.
►NSqlScriptSupport
CSqlScriptRunnerTasklet	This tasklet launches a sql script.
►NTemplate
CAbstractTemplateLineAggregator	Abstract base class for implementations of ITemplateLineAggregator<T>.
CITemplateLineAggregator	Interface for template line aggregators. It exposes the TemplateId property that holds the id of the template line to use.
►NUtils
CBigDecimalUtils	Big Decimal Helper.
CBigIntegerUtils	Big Integer Helper.
CDateUtils	DateUtils utilitary class.
CDoubleUtils	Double helper.
CIntegerUtils	Int helper
CLongUtils	Long Helper.
CMapUtils	Dictionary helper.
CObjectUtils	Object helper.
CReverseUtils	Reverse Helper.
CStringUtils	String helper.
CAbstractExecutionListener	Common implementation of the pre processor, processor and post processor. Manages step and job contexts.
CBatchConstants	Constants used in extra batch support classes.
CContextManager	Used to manage objects cache in Jobs/Steps. The execution context contains information on the current Job/Step being executed.
CContextManagerUnityLoader	Unity loader registering context managers.
CDateParser	The default date parser
CDummyItemReader	Dummy reader that will always return a unique result (DefaultResult).
CDummyItemWriter	Writer which does nothing on purpose.
CIBooleanEncoder	Interface for boolean encoders
CIContextManager	Interface for context manager
CIDateParser	Interface for date parsers.
CIItemCondition	An Item Condition used to write records conditionally.
CWriterResourceManager	Prepares the step by initalizing the process writers called inside
CZeroOneBooleanEncoder	Simple boolean encoder returning "0" or "1"
▼NInfrastructure
►NItem
►NDatabase
CDatabaseBatchItemWriter	Implementation of T:IItemWriter that writes items in a database using a T:IQueryParameterSourceProvider to retrieve the parameter values for each update/insert.
CDataReaderItemReader	Implementation of T:IItemReader that reads items from a database using a DbDataReader. It creates its own connection as it will be busy until the reader is closed.
CEmptyUpdateException	Exception thrown when an insert or an update query is expected to affect at least one record but no records were affected.
►NFile
►NMapping
CDefaultLineMapper	Implementation of T:ILineMapper that maps the line in two phases: first the line is separated in fields using a ILineTokenizer, then the resulting IFieldSet is mapped to an entity using a T:IFieldSetMapper.
CIFieldSetMapper	Interface used to map a IFieldSet to an item.
►NTransform
CAbstractLineTokenizer	Abstract base class for ILineTokenizer implementations.
CDefaultFieldSet	Default implementation of IFieldSet.
CDefaultFieldSetFactory	Default implementation of IFieldSetFactory.
CDelimitedLineAggregator	An implementation of T:ILineAggregator that converts an object into a delimited list of strings. The default delimiter is a comma.
CDelimitedLineTokenizer	Implementation of ILineTokenizer that splits the input string using a configurable delimiter. A column can be surrounded by a configurable quote character to include the delimiter.
CExtractorLineAggregator	Abstract implementation of T:ILineAggregator that uses a T:IFieldExtractor to convert the incoming object to an array of its parts.
CFixedLengthTokenizer	Implementation of ILineTokenizer for lines with fixed-length format. Columns are specified using ranges.
CFormatterLineAggregator	Implementation of T:ILineAggregator that produces a string by aggregating the provided item with string.Format(System.IFormatProvider,string,object[]).
CIFieldExtractor	Interface to convert an object to an array of its parts.
CIFieldSet	Interface used by flat file input sources to read data from a string array.
CIFieldSetFactory	Factory for creating IFieldSet instances.
CILineAggregator	Interface used to create a string representing an object.
CILineTokenizer	Interface used to split a line into tokens.
CPassThroughFieldExtractor	An implementation of T:IFieldExtractor that returns the original item. If it is an array it is returned as is. Collections, dictionaries, and field sets are converted to array. In any other cases the object is wrapped in a single element array
CPassThroughLineAggregator	Implementation of T:ILineAggregator that simply calls object.ToString.
CPropertyFieldExtractor	Implementation of T:IFieldExtractor that retrieve values from property names.
CRange	A class to represent ranges. The range minimum and maximum can have values from 1 to int.MaxValue. If the maximum is UnboundMaximum, it is considered to be unbound on the right side.
CFlatFileItemReader	A restartable T:Summer.Batch.Item.ItemReader that reads lines from a T:Summer.Batch.IO.Resource. A line is mapped using a T:Summer.Batch.Item.File.LineMapper.
CFlatFileItemWriter	A restartable T:Summer.Batch.Item.ItemWriterthat writes to a T:Summer.Batch.IO.IResource. A T:LineAggregator is used to write lines from items.
CFlatFileParseException	Exception thrown when errors are encountered while parsing flat files.
CIFooterWriter	Interface for writing a footer to a file.
CIHeaderWriter	Interface for writing a header to a file.
CILineMapper	Interface for mapping lines to entities.
CIResourceAwareItemReaderItemStream	Interface of T:IItemReaders that implement IItemStream and read from a T:Summer.Batch.IO.IResource.
CIResourceAwareItemWriterItemStream	Interface for T:IItemWriters that implement IItemStream and write to a Summer.Batch.Common.IO.IResource.
CMultiResourceItemReader	Reads items from a collection of resources sequentially. Ordering of resources is preserved between jobs runs (restartability support) using the provided comparer.
CNonTransientFlatFileException	Exception thrown when errors are encountered with the underlying resource.
►NSupport
CAbstractItemCountingItemStreamItemReader	Abstract superclass for IItemReaders that supports restart by storing item count in the execution context and therefore requires item ordering to be preserved between runs.
CAbstractItemStreamItemReader	Base class for T:IItemReader implementations.
CAbstractItemStreamItemWriter	Base class for ItemWriter implementations.
CCompositeItemStream	Simple IITemStream that delegates to a list of other streams.
CCompositeItemWriter	Calls a collection of IItemWriter. Delegate writers are kept in an ordered collection. Thread-safe, provided delegates are thread-safe as well.
CListItemReader	Simple item reader that pulls its data from a supplied list.
CListItemWriter	Simple item writer that populates a List with the elements to be written.
►NUtil
CExecutionContextUserSupport	Facilitates data persistence in the execution context, with keys based on a name.
CFileUtils	File operations helper.
CItemStreamSupport	Basic implementation of IItemStream.
CExecutionContext	Object representing a context for an IItemStream. It is a thin wrapper for a dictionary that allows optionally for type safety on reads. It also allows for dirty checking by setting a 'dirty' flag whenever any put is called
CIItemProcessor	Item processor. This is where item given as input (TIn) is being processed to be transformed into the output (TOut). Input and Output types can be different. Convention: Returning null indicates that this item should not be continued to be processed.
CIItemReader	Strategy interface for providing the data. Implementations are expected to be stateful and will be called multiple times for each batch, with each call to Read() returning a different value and finally returning null when all input data is exhausted. Implementations need not be thread-safe and clients of a IItemReader need to be aware that this is the case. A richer interface (e.g. with a look ahead or peek) is not feasible because we need to support transactions in an asynchronous batch.
CIItemStream	Interface for periodically storing and restoring state should an error occur.
CIItemStreamReader	Convenience interface that combines IItemStream and T:IItemReader.
CIItemStreamWriter	Convenience interface that combines IItemStream and T:IItemWriter
CIItemWriter	Basic interface for generic output operations. Class implementing this interface will be responsible for serializing objects as necessary. Generally, it is responsibility of implementing class to decide which technology to use for mapping and how it should be configured
CItemReaderException	A base exception class that all exceptions thrown from an IItemReader extend.
CItemStreamException	Exception representing any errors encountered while processing a stream.
CItemWriterException	A base exception class that all exceptions thrown from an ITemWriter extend.
CNonTransientResourceException	Exception indicating that an error has been encountered doing I/O from a reader, and the exception should be considered fatal.
CParseException	Exception indicating that an error has been encountered parsing IO, typically from a file.
CReaderNotOpenException	Exception indicating that an IItemReader needs to be opened before read.
CUnexpectedInputException	Used to signal an unexpected end of an input or message stream. This is an abnormal condition, not just the end of the data - e.g. if a resource becomes unavailable, or a stream becomes unreadable.
CWriteFailedException	Unchecked exception indicating that an error has occurred while trying to clear a buffer on a rollback.
CWriterNotOpenException	Exception indicating that an ITemWriter needs to be opened before being written to.
►NRepeat
►NContext
CRepeatContextSupport	Support for repeat context.
CSynchronizedAttributeAccessor	An AttributeAccessor that synchronizes on a mutex (not this) before modifying or accessing the underlying attributes.
►NException
CDefaultExceptionHandler	Default implementation of IExceptionHandler - just re-throws the exception it encounters.
CIExceptionHandler	Handler to allow strategies for re-throwing exceptions. Normally a CompletionPolicy will be used to decide whether to end a batch when there is no exception, and the ExceptionHandler is used to signal an abnormal ending - an abnormal ending would result in an ExceptionHandler throwing an exception. The caller will catch and re-throw it if necessary.
►NPolicy
CCompletionPolicySupport	Very simple base class for ICompletionPolicy implementations.
CDefaultResultCompletionPolicy	Very simple ICompletionPolicy that bases its decision on the result of a batch operation. If the result is null or not continuable according to the RepeatStatus the batch is complete, otherwise not.
►CSimpleCompletionPolicy	Policy for terminating a batch after a fixed number of operations. Internal state is maintained and a counter incremented, so successful use of this policy requires that IsComplete() is only called once per batch item. Using the standard RepeatTemplate should ensure this contract is kept, but it needs to be carefully monitored.
CSimpleTerminationContext	SimpleTerminationContext
►NSupport
CIRepeatInternalState	Internal interface for extensions of RepeatTemplate.
CIResultHolder	Interface for result holder.
CIResultQueue	Abstraction for queue of IResultHolder objects. Acts a bit like a BlockingQueue with the ability to count the number of items it expects to ever hold. When clients schedule an item to be added they call Expect()}, and then collect the result later with Take(). Result providers in another thread call Put(Object) to notify the expecting client of a new result.
CRepeatInternalStateSupport	Internal state support for Repeat. Mainly used to store encountered exceptions.
CRepeatSynchronizationManager	Global variable support for repeat clients. Normally it is not necessary for clients to be aware of the surrounding environment because a IRepeatCallback can always use the context it is passed by the enclosing IRepeatOperations. But occasionally it might be helpful to have lower level access to the ongoing IRepeatContext so we provide a global accessor here. The mutator methods (Clear() and Register(IRepeatContext) should not be used except internally by IRepeatOperations implementations.
CRepeatTemplate	Simple implementation and base class for batch templates implementing RepeatOperations. Provides a framework including interceptors and policies. Subclasses just need to provide a method that gets the next result and one that waits for all the results to be returned from concurrent processes or threads
CResultHolderResultQueue	An implementation of the Summer.Batch.Infrastructure.Repeat.Support.IResultQueue<TB> that throttles the number of expected results, limiting it to a maximum at any given time.
CTaskExecutorRepeatTemplate	Support for RepeatOperations, including interceptors (used to modify or monitor the behavior at run time). Thread-safe class, provided that its collaborators are thread-safe as well.
CICompletionPolicy	Interface for batch completion policies, to enable batch operations to strategise normal completion conditions. Stateful implementations of batch iterators should only update state using the update method. If you need custom behaviour consider extending an existing implementation or using the composite provided.
CIRepeatContext	Base interface for context which controls the state and completion / termination of a batch step. A new context is created for each call to the IRepeatOperations. Within a batch callback code can communicate via the IAttributeAccessor interface.
CIRepeatListener	Interface for listeners to the batch process. Implementers can provide enhance the behaviour of a batch in small cross-cutting modules. The framework provides callbacks at key points in the processing.
CIRepeatOperations	The main interface providing access to batch operations. The batch client is the RepeatCallback, where a single item or record is processed. The batch behaviour, boundary conditions, transactions etc, are dealt with by the RepeatOperations in such as way that the client does not need to know about them. The client may have access to framework abstractions, like template data sources, but these should work the same whether they are in a batch or not.
CRepeatException	Exception thrown when repeat issues occur.
CRepeatStatus	Enumeration of possible Repeat statuses (either "Continuable" or "Finished")
►NSupport
►NTransaction
CTransactionAwareFileStream	File Stream with transactionnal write behaviour support.
CIMethodInvoker	A strategy interface for invoking a method (adapters).
CPatternMatcher	PatternMatcher
CPropertiesConverter	Properties converter helper (NameValueCollection to String, and back).