|
||||||||||
| PREV NEXT | FRAMES NO FRAMES | |||||||||
ComponentBuilder implementation.EntitySource
to be used as parent class for custom implementations.Generator implementation which holds a state and state management methods.NullableGenerator implementation which holds a state and state management methods.Task tests.WeightFunction interface.Consumer implementation which sums up the values of a 'feature' of all objects it consumes
and return the sum as 'sum' property of type 'type'.Address objects.ComponentBuilder implementation which builds array elements.ArrayTypeDescriptor.Generators.Number products of another Generator to BigDecimal.Number products of another Generator to BigInteger.Number products of another Generator to Byte.Number products of another Generator to Float.Number products of another Generator to Integer.Generator with a NullableGenerator.Number products of another Generator to Short.x.y = f.d + 3.IndividualWeight implementation that weighs objects individually.Consumer proxy that forwards data to 'real consumer' and if the real consumer
raises an error, forwards the data to a 'bad data consumer'.BankAccounts with low validity requirements.BankAccount.BankAccounts with low validity requirements.Expression implementation that instantiates a JavaBean by default constructor and
calls its property setters for initializing state.Task implementation that instantiates a JavaBean.Statement that emits a beep.ParseContext implementation for Benerator.Statement for executing descriptor file based data generation.Script implementation for BeneratorScript.ScriptFactory implementation for BeneratorScript.Date objects for a person's birth day.Sequence implementation for a distribution that creates the bit-reverses (r)
of a continuous series, e.g. r(1), r(2), r(3), ...; the numbers produced by a related
generator are unique as long as the generator is not reset.target
City objects.Generator.close()
ComponentDescriptors.ComponentBuilders.ComponentBuilder.ComponentBuilders and applies them to an Entity.ComplexTypeDescriptor.Generator implementation that makes use of other ContextAware
objects by which its threading support is influenced.Generators and combines them to a result String.Task that wrap several other Tasks.Generator implementation that wraps several String generators
and concatenates their results to a composite String.Expression that combines the result
of two other boolean expressions with a logical AND.ComponentBuilder which executes only if a condition expression evaluates to 'true'.Expression implementation that evaluates a boolean (condition) expression
and, depending if the result was true or false, evaluates the first or second expression delegate.CompositeStatement that holds a condition expression.NullableGenerator implementation which returns a constant value
(supporting null as value).Invoker implementation which calls the Consumer.startConsuming(Object)
method with the provided argument.Consumers that serve as proxy to other Consumers.ContextAware interface.Context.NullableGenerator.Entity data from CSV files.EntitySource implementation which creates Iterables that iterate through CSV files.Sequence implementation for an efficient bell-like distribution.Distribution implementation which uses the inverse of a probability function integral
for efficiently generating numbers with a given probability distribution.CumulativeDistributionFunction.Date objects that represent the current time.Datasets.TypeArithmetic implementation for the Date class.VersionNumberComponent interface,
which exhibits the same ordinal behavior as a snapshot version.Dates by their day of week.DBSanityStatement.Statement implementation that performs DB Sanity checks
and raises an error in case of check violations.Long values with a HiLo strategy using a database sequence for the Hi values.Long values from a database sequence.StorageSystem interface.BeneratorFactory class.ComponentBuilders which uses a Mutator
object for abstracting the target object type.BeneratorContext.Locale-specific CSV file.Strings composed of numerical digits.Generator is able to generate,
puts them into a list and serves the list elements based on its
Distribution.SampleGenerator and a Distribution's
Distribution.createGenerator(Class, Number, Number, Number, boolean)
method for acting as a Generator proxy.Distribution to use when generating data for the
annotated element.Expression that performs a division.DynamicLongGenerator,
but generates maxFallback values, if max is set to null.Generator implementation that generates Long numbers,
redefining the underlying distribution on each reset() by
evaluating the min, max, precision,
distribution and unique values.FolderLayout for Eclipse.Statement implementation that does not do anything, sometimes useful for testing.ComplexTypeDescriptor.Expression that compares two terms for equality of their results.onError attribute in an XML descriptor element.ErrorStatement.Statement implementation that raises a BeneratorError
and provides a result code for the operating system.Expression that returns the ExecutorService
of the BeneratorContext.GeneratorProxy implementation that supports distribution of unlimited data volumes
(provided by a source generator) in a unique or non-unique manner.Sequence implementation that makes use of Benerator's ExpandGeneratorProxy
for distributing data of unlimited volume in a unique or non-unique manner.Expression on each call to ExpressionBasedGenerator.generate()
and returns its results.Sequence-based implementation of the
Fibonacci SequenceEntitySources that import entities from files.File objects which represent files and/or directories in a parent directory.Double or Float)
to be min plus an integral multiple of precision.StorageSystem.store(Entity)d, is send to the target system.
Gender enumeration value to a configurable String.Gender objects.Generator.generate()
Generator to use when generating data for the annotated element.Generators.Expression implementation that evaluates to a Generator.Statements that make use of a GeneratorTask.Tasks that use a Generator to generate data
and a Consumer to consume it.Locale
Locale of which letters are taken
Locale
CompositeStatement that executes it parts
only if a condition is matched.IndividualWeight distributions.Byte, Short, Integer, Long)
to be min plus an integral multiple of precision.Expression implementation that evaluates a method on a class or object.true to indicate parallelization support,
but may be overwritten by child classes.
true to indicate thread-safety and may not be overwritten by child classes.
Iterable.Consumer implementation that maps input data to parameters
and invokes a method on a Java object with them.LanguageResourceBundle class.LanguageResourceBundle class.Statement implementation that evaluates an Expression
which returns a Task and executes the returned Task.ComplexTypeDescriptor that reads its components from a database table.Consumer implementation that stores all consumed objects in a List.Sequence implementation that provides values specified in a comma-separated value list,
use like "new PredefinedSequence('A', 'B', 'C')" or "new PredefinedSequence(5, 7, 11)".Generator that behaves like a database sequence.Consumer that logs the entities that it receives at info level.Sequence implementations
that are based on a Long-value generator (Generator<Long>).Generators that generate Long values.IndividualWeightGenerator implementation that organizes
sample data in a Map of value-weight associations.Consumer which maps attribute names of the entities.FolderLayout.TaskRunner implementation that is able to execute a Task with multiple threads.Converter implementation that transforms numbers
inducing relative or absolute numerical noise based on a Distribution.Expression that checks for inequality.Nouns of a given Locale.null values.NullableGenerators.NullableGenerator.NullableGenerator.null as a valid value.NullableGenerator interface.NullableGenerator interface.null values to produce when generating data for the annotated element.VersionNumberComponent.Sequence-based implementation of the
Padovan SequenceTaskRunner implementation that provides for repeated, paged,
multi- or single-threaded Task execution.Expression implementation that instantiates a Java object by constructor invocation.Consumer implementation that calls a ContiPerf PerfTrackingConsumer.Task and tracks its execution times.Person objects.Person beans.Country.Validator that verifies postal codes.Generator class for use by the LiteralSequence.NullableGenerator.Expression instance that evaluates the Benerator script notation for Java object specification
as one of the following:
reference: myInstance
class name: com.my.SpecialClass
constructor invocation: new com.my.SpecialClass(3, 'test')
JavaBean property syntax: new com.my.SpecialClass[id=3, name='test']
Expression implementation that evaluates a qualified name as attributes of an object reference or
static fields of a Java class.Expression implementation that evaluates an invocation syntax on a qualified name
as static method call or call on an object reference.Long values based on a database query.BigDecimals with a uniform distribution.BigInteger with a uniform distribution.Integer values with a uniform distribution.Sequence implementation that creates generators with a random uniform distribution.Sequence implementation that supports a variable step width.ComplexTypeDescriptor).Resettable.reset()
ResourceManager interface.ResultSet to a Benerator Entity.Statement that executes a Task supporting paging and multithreading.Objects based on a Script.Sequence.Sequences.Locale of which letters are taken
XMLElementParser implementation for parsing a Benerator descriptor file's root XML element.increment value; when max is reached, it
repeats the procedure starting by min+precision, later min+2*precision and so on.Sequence implementation that implements a 'shuffle' behavior,
by continuously incrementing a base value by a constant value and,
when iterated through the number range, restarts with a value incremented by one.Generators that are neither thread-safe nor parallelizable.TaskRunner implementation that executes a Task with the current thread.Distribution
to use when generating data for the annotated element
Created: 02.05.2010 19:01:02Generator proxy that combines a 'source' entity generator
with variable support and ComponentBuilders.Iterables for iterating through data sources.Statement.available.StorageSystem.Consumer implementation that inserts entities into database tables.Consumer implementation that updates database rows.Distribution spec,
supporting the predefined sequences, like 'random' and 'cumulated'.Expression that resolves a script as String.VersionNumberComponent implementation for String-type number components.Expression that performs a subtraction.Generator implementations.TaskProxy implementation that add thread-safety to an unsafe
Task by synchronizing the method Task.execute(Context, ErrorHandler).Invoker implementation that calls Task.execute(Context, ErrorHandler).Tasks.Tasks.Strings.ThreadLocal implementation that wraps a ProductWrapper for reuse.TypeArithmetic implementation for Time objects.TypeArithmetic implementation for the Date type.Generator implementation which takes cells from a CSV file as input
and combines the cells by taking a cell value from a random row for each column
and concatenating them to a string.Statement that transcodes a database table.TranscodeStatements and provides common features like
IdentityProvider and KeyMapper objects.Expression implementation that evaluates a script.UUID.randomUUID().NullableGenerator that only generates products which pass a validator.Sequence implementation that creates Number Generator with a wedge distribution.Generators that are based on weights.Dataset.Generators that converts
their products to a target Number type.Entity instances.EntitySource that reads Entities from an Excel sheet.SourceFactory implementation which creates XLS entity sources.Consumer specification in an XML element in a descriptor file.
|
||||||||||
| PREV NEXT | FRAMES NO FRAMES | |||||||||