|
||||||||||
PREV NEXT | FRAMES NO FRAMES |
Uses of Generator in org.databene.benerator |
---|
Subinterfaces of Generator in org.databene.benerator | |
---|---|
interface |
NonNullGenerator<E>
Generator interface which declares a NonNullGenerator.generate() method as in Benerator versions before 0.7. |
interface |
WeightedGenerator<E>
Parent interface for Generator s that have a weight to be considered when combining Generators. |
Methods in org.databene.benerator that return Generator | |
---|---|
Generator<E> |
GeneratorProvider.create()
|
Uses of Generator in org.databene.benerator.anno |
---|
Methods in org.databene.benerator.anno that return Generator | |
---|---|
Generator<?> |
AnnotationMapper.createAndInitAttributeGenerator(java.lang.reflect.Field attribute,
BeneratorContext context)
scans test class attributes for attributes with @ Source annotation
and initializes them with a value from the referred source object |
Generator<java.lang.Object[]> |
AnnotationMapper.createAndInitMethodParamsGenerator(java.lang.reflect.Method testMethod,
BeneratorContext context)
|
protected Generator<java.lang.Object[]> |
AnnotationMapper.createGenerator(ArrayTypeDescriptor type,
java.lang.reflect.Method testMethod,
Uniqueness uniqueness,
BeneratorContext context)
|
Uses of Generator in org.databene.benerator.composite |
---|
Classes in org.databene.benerator.composite that implement Generator | |
---|---|
class |
BlankArrayGenerator
Generates an array of fixed size filled with nulls. |
class |
BlankEntityGenerator
Instantiates an entity without initializing any components. |
class |
SimpleTypeEntityGenerator
Generates Entities that wrap a content of simple type. |
class |
SimplifyingSingleSourceArrayGenerator<S>
Creates a stochastic number of instances of a type. |
class |
SourceAwareGenerator<E>
Generator proxy that combines a 'source' entity generator
with variable support and ComponentBuilders. |
Fields in org.databene.benerator.composite declared as Generator | |
---|---|
protected Generator<?> |
AbstractGeneratorComponent.source
|
Methods in org.databene.benerator.composite that return Generator | |
---|---|
Generator<?> |
AbstractGeneratorComponent.getSource()
|
Constructors in org.databene.benerator.composite with parameters of type Generator | |
---|---|
AbstractComponentBuilder(Generator<?> source,
org.databene.commons.Mutator mutator,
java.lang.String scope)
|
|
AbstractGeneratorComponent(Generator<?> source,
java.lang.String scope)
|
|
ArrayElementBuilder(int index,
Generator<?> source,
java.lang.String scope)
|
|
PlainEntityComponentBuilder(java.lang.String name,
Generator<?> source,
java.lang.String scope)
|
|
SimpleTypeEntityGenerator(Generator<?> source,
ComplexTypeDescriptor complexType)
|
|
SimplifyingSingleSourceArrayGenerator(Generator<S> source,
NonNullGenerator<java.lang.Integer> countGenerator)
|
|
SourceAwareGenerator(java.lang.String instanceName,
Generator<E> source,
java.util.List<GeneratorComponent<E>> components,
BeneratorContext context)
|
|
Variable(java.lang.String name,
Generator<?> source,
java.lang.String scope)
|
Uses of Generator in org.databene.benerator.csv |
---|
Classes in org.databene.benerator.csv that implement Generator | |
---|---|
class |
LocalCSVGenerator<E>
Generates data from a localized csv file. |
class |
SequencedDatasetCSVGenerator<E>
Generates values from a dataset based on a Sequence . |
class |
WeightedDatasetCSVGenerator<E>
Generates data from a csv file set that is organized as Dataset . |
Uses of Generator in org.databene.benerator.dataset |
---|
Subinterfaces of Generator in org.databene.benerator.dataset | |
---|---|
interface |
DatasetBasedGenerator<E>
Interface for dataset related Generator s
which can generate data with and for dedicated sub sets. |
interface |
WeightedDatasetGenerator<E>
Parent interface for DatasetBasedGenerator s that have a weight to be considered when combining Generators. |
Classes in org.databene.benerator.dataset that implement Generator | |
---|---|
class |
AbstractDatasetGenerator<E>
Abstract implementation of the DatasetBasedGenerator interface. |
class |
AtomicDatasetGenerator<E>
DatasetBasedGenerator implementation which bases on an atomic dataset. |
class |
CompositeDatasetGenerator<E>
DatasetBasedGenerator implementation which bases on a composite dataset. |
Constructors in org.databene.benerator.dataset with parameters of type Generator | |
---|---|
AtomicDatasetGenerator(Generator<E> source,
java.lang.String nesting,
java.lang.String dataset,
double weight)
|
Uses of Generator in org.databene.benerator.distribution |
---|
Classes in org.databene.benerator.distribution that implement Generator | |
---|---|
static class |
CumulativeDistributionFunction.IPINumberGenerator<E extends Number>
Generates numbers according to an CumulativeDistributionFunction . |
class |
DistributingGenerator<E>
General purpose generator proxy which is supposed to work with any distribution. |
class |
IndexBasedSampleGeneratorProxy<E>
Internal generator which reads all products of a source generator and provides them with an index-based strategy. |
class |
WeightedDoubleGenerator
Double Generator that supports a weight function. |
class |
WeightedLongGenerator
Long Generator that supports a weight function. |
Methods in org.databene.benerator.distribution that return Generator | ||
---|---|---|
|
Sequence.applyTo(Generator<T> source,
boolean unique)
|
|
|
IndividualWeight.applyTo(Generator<T> source,
boolean unique)
|
|
|
Distribution.applyTo(Generator<T> source,
boolean unique)
|
|
|
CumulativeDistributionFunction.applyTo(Generator<T> source,
boolean unique)
|
|
|
AbstractWeightFunction.applyTo(Generator<T> source,
boolean unique)
|
Methods in org.databene.benerator.distribution with parameters of type Generator | ||
---|---|---|
|
Sequence.applyTo(Generator<T> source,
boolean unique)
|
|
|
IndividualWeight.applyTo(Generator<T> source,
boolean unique)
|
|
|
Distribution.applyTo(Generator<T> source,
boolean unique)
|
|
|
CumulativeDistributionFunction.applyTo(Generator<T> source,
boolean unique)
|
|
|
AbstractWeightFunction.applyTo(Generator<T> source,
boolean unique)
|
Constructors in org.databene.benerator.distribution with parameters of type Generator | |
---|---|
DistributingGenerator(Generator<E> dataProvider,
Distribution distribution,
boolean unique)
|
|
IndexBasedSampleGeneratorProxy(Generator<E> dataProvider,
Distribution distribution,
boolean unique)
|
Uses of Generator in org.databene.benerator.distribution.sequence |
---|
Classes in org.databene.benerator.distribution.sequence that implement Generator | |
---|---|
class |
BitReverseLongGenerator
Generates integers reversing the bits of a continuously rising number. |
class |
BitReverseNaturalNumberGenerator
Long Generator that implements a 'bitreverse' Long Sequence. |
class |
CumulatedDoubleGenerator
Double Generator that implements a 'cumulated' Double Sequence. |
class |
CumulatedLongGenerator
Long Generator that implements a 'cumulated' Long Sequence. |
class |
ExpandGeneratorProxy<E>
GeneratorProxy implementation that supports distribution of unlimited data volumes
(provided by a source generator) in a unique or non-unique manner. |
class |
PredefinedSequenceGenerator<E extends Number>
Generator class for use by the LiteralSequence . |
class |
RandomBigDecimalGenerator
Generates random BigDecimal s with a uniform distribution. |
class |
RandomBigIntegerGenerator
Generates random BigInteger with a uniform distribution. |
class |
RandomDoubleGenerator
Double Generator that implements a 'random' Double Sequence. |
class |
RandomIntegerGenerator
Creates random Integer values with a uniform distribution. |
class |
RandomLongGenerator
Long Generator that implements a 'random' Long Sequence. |
class |
RandomWalkDoubleGenerator
Double Generator that implements a 'randomWalk' Double Sequence. |
class |
RandomWalkLongGenerator
Long Generator that implements a 'randomWalk' Long Sequence. |
class |
ShuffleDoubleGenerator
Double Generator that implements a 'shuffle' Double Sequence. |
class |
ShuffleLongGenerator
Long Generator that implements a 'shuffle' Long Sequence: It starts with min and produced numbers by continuously incrementing the cursor by a fix increment value; when max is reached, it
repeats the procedure starting by min+granularity, later min+2*granularity and so on. |
class |
StepDoubleGenerator
Double Generator that implements a 'step' Double Sequence. |
class |
StepLongGenerator
Long Generator that implements a 'step' Long Sequence. |
class |
WedgeDoubleGenerator
Generates 'Double' values for the 'wedge' sequence. |
class |
WedgeLongGenerator
Long Generator that implements a 'wedge' Long Sequence. |
Methods in org.databene.benerator.distribution.sequence that return Generator | ||
---|---|---|
|
WeightedNumbers.applyTo(Generator<T> source,
boolean unique)
|
|
|
StepSequence.applyTo(Generator<T> source,
boolean unique)
|
|
|
RepeatSequence.applyTo(Generator<T> source,
boolean unique)
|
|
|
RandomWalkSequence.applyTo(Generator<T> source,
boolean unique)
|
|
|
RandomSequence.applyTo(Generator<T> source,
boolean unique)
|
|
|
HeadSequence.applyTo(Generator<T> source,
boolean unique)
|
|
|
ExpandSequence.applyTo(Generator<T> source,
boolean unique)
|
Methods in org.databene.benerator.distribution.sequence with parameters of type Generator | ||
---|---|---|
|
WeightedNumbers.applyTo(Generator<T> source,
boolean unique)
|
|
|
StepSequence.applyTo(Generator<T> source,
boolean unique)
|
|
|
RepeatSequence.applyTo(Generator<T> source,
boolean unique)
|
|
|
RandomWalkSequence.applyTo(Generator<T> source,
boolean unique)
|
|
|
RandomSequence.applyTo(Generator<T> source,
boolean unique)
|
|
|
HeadSequence.applyTo(Generator<T> source,
boolean unique)
|
|
|
ExpandSequence.applyTo(Generator<T> source,
boolean unique)
|
|
static
|
ExpandGeneratorProxy.uniqueProxy(Generator<T> source,
int cacheSize,
int bucketSize)
|
Constructors in org.databene.benerator.distribution.sequence with parameters of type Generator | |
---|---|
ExpandGeneratorProxy(Generator<E> source,
float duplicationQuota)
|
|
ExpandGeneratorProxy(Generator<E> source,
float duplicationQuota,
int cacheSize)
|
|
ExpandGeneratorProxy(Generator<E> source,
float duplicationQuota,
int cacheSize,
int bucketSize)
|
Uses of Generator in org.databene.benerator.engine |
---|
Classes in org.databene.benerator.engine that implement Generator | |
---|---|
class |
DescriptorBasedGenerator
Provides easy programmatic access to generators defined in an XML descriptor file. |
class |
TaskBasedGenerator
Wraps a GenerateAndConsumeTask with a Generator interface. |
Methods in org.databene.benerator.engine that return Generator | |
---|---|
Generator<?> |
BeneratorRootStatement.getGenerator(java.lang.String name,
BeneratorContext context)
|
Constructors in org.databene.benerator.engine with parameters of type Generator | |
---|---|
CurrentProductGeneration(java.lang.String instanceName,
Generator<?> source)
|
Uses of Generator in org.databene.benerator.engine.expression |
---|
Constructors in org.databene.benerator.engine.expression with parameters of type Generator | |
---|---|
GeneratorExpression(Generator<E> generator)
|
Uses of Generator in org.databene.benerator.engine.parser.xml |
---|
Methods in org.databene.benerator.engine.parser.xml with parameters of type Generator | |
---|---|
protected GenerateOrIterateStatement |
GenerateOrIterateParser.createStatement(java.lang.String productName,
Generator<java.lang.Long> countGenerator,
org.databene.script.Expression<java.lang.Long> minCount,
org.databene.script.Expression<java.lang.Long> pageSize,
org.databene.script.Expression<PageListener> pager,
boolean infoLog,
boolean nested,
org.w3c.dom.Element element,
org.databene.script.Expression<org.databene.commons.ErrorHandler> errorHandler,
BeneratorContext context)
|
Constructor parameters in org.databene.benerator.engine.parser.xml with type arguments of type Generator | |
---|---|
SettingParser.SourceExpression(org.databene.script.Expression<Generator<E>> source)
|
Uses of Generator in org.databene.benerator.engine.statement |
---|
Fields in org.databene.benerator.engine.statement declared as Generator | |
---|---|
protected Generator<java.lang.Long> |
GenerateOrIterateStatement.countGenerator
|
Constructors in org.databene.benerator.engine.statement with parameters of type Generator | |
---|---|
GenerateOrIterateStatement(java.lang.String productName,
Generator<java.lang.Long> countGenerator,
org.databene.script.Expression<java.lang.Long> minCount,
org.databene.script.Expression<java.lang.Long> pageSize,
org.databene.script.Expression<PageListener> pageListenerEx,
org.databene.script.Expression<org.databene.commons.ErrorHandler> errorHandler,
boolean infoLog,
boolean isSubCreator,
BeneratorContext context)
|
Uses of Generator in org.databene.benerator.factory |
---|
Methods in org.databene.benerator.factory that return Generator | ||
---|---|---|
protected Generator<?> |
ArrayTypeGeneratorFactory.applyComponentBuilders(Generator<?> generator,
ArrayTypeDescriptor descriptor,
java.lang.String instanceName,
Uniqueness uniqueness,
BeneratorContext context)
|
|
protected Generator<?> |
ComplexTypeGeneratorFactory.applyComponentBuilders(Generator<?> generator,
ComplexTypeDescriptor descriptor,
java.lang.String instanceName,
Uniqueness uniqueness,
BeneratorContext context)
|
|
protected Generator<?> |
TypeGeneratorFactory.applyComponentBuilders(Generator<?> generator,
E descriptor,
java.lang.String instanceName,
Uniqueness uniqueness,
BeneratorContext context)
|
|
Generator<?> |
StochasticGeneratorFactory.applyNullSettings(Generator<?> source,
java.lang.Boolean nullable,
java.lang.Double nullQuota)
|
|
Generator<?> |
SerialGeneratorFactory.applyNullSettings(Generator<?> source,
java.lang.Boolean nullable,
java.lang.Double nullQuota)
|
|
abstract Generator<?> |
GeneratorFactory.applyNullSettings(Generator<?> source,
java.lang.Boolean nullable,
java.lang.Double nullQuota)
|
|
Generator<?> |
EquivalenceGeneratorFactory.applyNullSettings(Generator<?> source,
java.lang.Boolean nullable,
java.lang.Double nullQuota)
|
|
protected Generator<?> |
TypeGeneratorFactory.applyRootWrappers(Generator<?> generator,
E descriptor,
java.lang.String instanceName,
Uniqueness uniqueness,
BeneratorContext context)
|
|
|
StochasticGeneratorFactory.createAlternativeGenerator(java.lang.Class<T> targetType,
Generator<T>[] sources,
Uniqueness uniqueness)
|
|
|
SerialGeneratorFactory.createAlternativeGenerator(java.lang.Class<T> targetType,
Generator<T>[] sources,
Uniqueness uniqueness)
|
|
abstract
|
GeneratorFactory.createAlternativeGenerator(java.lang.Class<T> targetType,
Generator<T>[] sources,
Uniqueness uniqueness)
|
|
|
EquivalenceGeneratorFactory.createAlternativeGenerator(java.lang.Class<T> targetType,
Generator<T>[] sources,
Uniqueness uniqueness)
|
|
Generator<java.lang.Boolean> |
StochasticGeneratorFactory.createBooleanGenerator(java.lang.Double trueQuota)
|
|
Generator<java.lang.Boolean> |
GeneratorFactory.createBooleanGenerator(java.lang.Double trueQuota)
Creates a generator for boolean values with a trueQuota [0-1] |
|
Generator<java.lang.Character> |
SerialGeneratorFactory.createCharacterGenerator(java.lang.String pattern,
java.util.Locale locale,
boolean unique)
|
|
Generator<java.lang.Character> |
GeneratorFactory.createCharacterGenerator(java.lang.String pattern,
java.util.Locale locale,
boolean unique)
Creates a Character generator that creates characters of a Locale which match a regular expression. |
|
Generator<java.lang.Character> |
EquivalenceGeneratorFactory.createCharacterGenerator(java.lang.String pattern,
java.util.Locale locale,
boolean unique)
|
|
|
StochasticGeneratorFactory.createCompositeArrayGenerator(java.lang.Class<T> componentType,
Generator<T>[] sources,
Uniqueness uniqueness)
|
|
|
SerialGeneratorFactory.createCompositeArrayGenerator(java.lang.Class<T> componentType,
Generator<T>[] sources,
Uniqueness uniqueness)
|
|
abstract
|
GeneratorFactory.createCompositeArrayGenerator(java.lang.Class<T> componentType,
Generator<T>[] sources,
Uniqueness uniqueness)
Creates a generator that reads products of an array of generators and combines them in an array. |
|
|
EquivalenceGeneratorFactory.createCompositeArrayGenerator(java.lang.Class<T> componentType,
Generator<T>[] sources,
Uniqueness uniqueness)
|
|
static Generator<?> |
InstanceGeneratorFactory.createConfiguredDefaultGenerator(java.lang.String componentName,
Uniqueness ownerUniqueness,
BeneratorContext context)
|
|
protected static Generator<?> |
SimpleTypeGeneratorFactory.createConstantGenerator(SimpleTypeDescriptor descriptor,
BeneratorContext context)
|
|
static Generator<?> |
VariableGeneratorFactory.createConvertingGenerator(TypeDescriptor descriptor,
Generator<?> generator,
BeneratorContext context)
|
|
static Generator<?> |
DescriptorUtil.createConvertingGenerator(TypeDescriptor descriptor,
Generator<?> generator,
BeneratorContext context)
|
|
static Generator<?> |
TypeGeneratorFactory.createConvertingGenerator(TypeDescriptor descriptor,
Generator generator,
BeneratorContext context)
|
|
static Generator<java.lang.String> |
SourceFactory.createCSVCellGenerator(java.lang.String uri,
char separator,
java.lang.String encoding)
Creates a generator that iterates through the cells of a CSV file. |
|
static Generator<java.lang.String[]> |
SourceFactory.createCSVGenerator(java.lang.String uri,
char separator,
java.lang.String encoding,
boolean ignoreEmptyLines,
boolean rowBased)
|
|
static Generator<java.lang.String[]> |
SourceFactory.createCSVLineGenerator(java.lang.String uri,
char separator,
java.lang.String encoding,
boolean ignoreEmptyLines)
Creates a generator that creates lines from a CSV file as String arrays. |
|
Generator<java.util.Date> |
SerialGeneratorFactory.createDateGenerator(java.util.Date min,
java.util.Date max,
long granularity,
Distribution distribution)
|
|
Generator<java.util.Date> |
GeneratorFactory.createDateGenerator(java.util.Date min,
java.util.Date max,
long granularity,
Distribution distribution)
Creates a Date generator that generates random dates. |
|
Generator<java.util.Date> |
EquivalenceGeneratorFactory.createDateGenerator(java.util.Date min,
java.util.Date max,
long granularity,
Distribution distribution)
|
|
Generator<java.util.Date> |
CoverageGeneratorFactory.createDateGenerator(java.util.Date min,
java.util.Date max,
long granularity,
Distribution distribution)
|
|
static Generator<java.lang.Long> |
DescriptorUtil.createDynamicCountGenerator(InstanceDescriptor descriptor,
java.lang.Long defaultMin,
java.lang.Long defaultMax,
boolean resetToMin,
BeneratorContext context)
|
|
protected Generator<?> |
TypeGeneratorFactory.createExplicitGenerator(E type,
Uniqueness uniqueness,
BeneratorContext context)
|
|
protected Generator<?> |
SimpleTypeGeneratorFactory.createExplicitGenerator(SimpleTypeDescriptor descriptor,
Uniqueness uniqueness,
BeneratorContext context)
|
|
|
StochasticGeneratorFactory.createFromWeightedLiteralList(java.lang.String valueSpec,
java.lang.Class<T> targetType,
Distribution distribution,
boolean unique)
|
|
|
SerialGeneratorFactory.createFromWeightedLiteralList(java.lang.String valueSpec,
java.lang.Class<T> targetType,
Distribution distribution,
boolean unique)
|
|
abstract
|
GeneratorFactory.createFromWeightedLiteralList(java.lang.String valueSpec,
java.lang.Class<T> targetType,
Distribution distribution,
boolean unique)
|
|
|
EquivalenceGeneratorFactory.createFromWeightedLiteralList(java.lang.String valueSpec,
java.lang.Class<T> targetType,
Distribution distribution,
boolean unique)
|
|
Generator<?> |
TypeGeneratorFactory.createGenerator(E descriptor,
java.lang.String instanceName,
boolean nullable,
Uniqueness uniqueness,
BeneratorContext context)
|
|
static Generator<?> |
VariableGeneratorFactory.createGenerator(VariableDescriptor descriptor,
BeneratorContext context)
|
|
protected Generator<?> |
ArrayTypeGeneratorFactory.createHeuristicGenerator(ArrayTypeDescriptor descriptor,
java.lang.String instanceName,
Uniqueness uniqueness,
BeneratorContext context)
|
|
protected Generator<?> |
ComplexTypeGeneratorFactory.createHeuristicGenerator(ComplexTypeDescriptor type,
java.lang.String instanceName,
Uniqueness uniqueness,
BeneratorContext context)
|
|
protected abstract Generator<?> |
TypeGeneratorFactory.createHeuristicGenerator(E descriptor,
java.lang.String instanceName,
Uniqueness uniqueness,
BeneratorContext context)
|
|
protected Generator<?> |
SimpleTypeGeneratorFactory.createHeuristicGenerator(SimpleTypeDescriptor descriptor,
java.lang.String instanceName,
Uniqueness uniqueness,
BeneratorContext context)
|
|
protected Generator<?> |
TypeGeneratorFactory.createInheritedGenerator(E type,
Uniqueness uniqueness,
BeneratorContext context)
|
|
static Generator<?> |
ComplexTypeGeneratorFactory.createMutatingEntityGenerator(java.lang.String name,
ComplexTypeDescriptor descriptor,
Uniqueness ownerUniqueness,
BeneratorContext context,
Generator<?> source)
|
|
|
StochasticGeneratorFactory.createNullGenerator(java.lang.Class<T> generatedType)
|
|
|
SerialGeneratorFactory.createNullGenerator(java.lang.Class<T> generatedType)
|
|
abstract
|
GeneratorFactory.createNullGenerator(java.lang.Class<T> generatedType)
|
|
|
EquivalenceGeneratorFactory.createNullGenerator(java.lang.Class<T> generatedType)
|
|
protected static Generator<?> |
InstanceGeneratorFactory.createNullGenerator(InstanceDescriptor descriptor,
BeneratorContext context)
|
|
static Generator<?> |
MetaGeneratorFactory.createNullGenerator(TypeDescriptor type,
BeneratorContext context)
|
|
static Generator<?> |
DescriptorUtil.createNullQuotaOneGenerator(InstanceDescriptor descriptor,
BeneratorContext context)
|
|
protected static Generator<java.lang.String> |
SimpleTypeGeneratorFactory.createPatternGenerator(SimpleTypeDescriptor type,
Uniqueness uniqueness,
BeneratorContext context)
|
|
static
|
SourceFactory.createRawSourceGenerator(java.lang.String nesting,
java.lang.String dataset,
java.lang.String sourceName,
DataSourceProvider<T> factory,
java.lang.Class<T> generatedType,
BeneratorContext context)
|
|
Generator<?> |
TypeGeneratorFactory.createRootGenerator(E descriptor,
java.lang.String instanceName,
boolean nullable,
Uniqueness uniqueness,
BeneratorContext context)
|
|
static Generator<?> |
MetaGeneratorFactory.createRootGenerator(InstanceDescriptor descriptor,
Uniqueness uniqueness,
BeneratorContext context)
|
|
|
StochasticGeneratorFactory.createSampleGenerator(java.util.Collection<T> values,
java.lang.Class<T> generatedType,
boolean unique)
|
|
|
SerialGeneratorFactory.createSampleGenerator(java.util.Collection<T> values,
java.lang.Class<T> generatedType,
boolean unique)
|
|
abstract
|
GeneratorFactory.createSampleGenerator(java.util.Collection<T> values,
java.lang.Class<T> generatedType,
boolean unique)
|
|
|
EquivalenceGeneratorFactory.createSampleGenerator(java.util.Collection<T> values,
java.lang.Class<T> generatedType,
boolean unique)
|
|
static Generator<?> |
FactoryUtil.createScriptGenerator(java.lang.String scriptText)
|
|
protected static Generator<?> |
TypeGeneratorFactory.createScriptGenerator(TypeDescriptor descriptor)
|
|
static Generator<?> |
InstanceGeneratorFactory.createSingleInstanceGenerator(InstanceDescriptor descriptor,
Uniqueness ownerUniqueness,
BeneratorContext context)
|
|
|
StochasticGeneratorFactory.createSingleValueGenerator(T value,
boolean unique)
|
|
|
SerialGeneratorFactory.createSingleValueGenerator(T value,
boolean unique)
|
|
abstract
|
GeneratorFactory.createSingleValueGenerator(T value,
boolean unique)
Creates a generator that returns a single value. |
|
|
EquivalenceGeneratorFactory.createSingleValueGenerator(T value,
boolean unique)
|
|
protected Generator<java.lang.Object[]> |
ArrayTypeGeneratorFactory.createSourceGenerator(ArrayTypeDescriptor descriptor,
Uniqueness uniqueness,
BeneratorContext context)
|
|
protected Generator<Entity> |
ComplexTypeGeneratorFactory.createSourceGenerator(ComplexTypeDescriptor descriptor,
Uniqueness uniqueness,
BeneratorContext context)
|
|
protected abstract Generator<?> |
TypeGeneratorFactory.createSourceGenerator(E descriptor,
Uniqueness uniqueness,
BeneratorContext context)
|
|
protected Generator<?> |
SimpleTypeGeneratorFactory.createSourceGenerator(SimpleTypeDescriptor descriptor,
Uniqueness uniqueness,
BeneratorContext context)
|
|
protected Generator<?> |
ArrayTypeGeneratorFactory.createSpecificGenerator(ArrayTypeDescriptor descriptor,
java.lang.String instanceName,
boolean nullable,
Uniqueness uniqueness,
BeneratorContext context)
|
|
protected Generator<?> |
ComplexTypeGeneratorFactory.createSpecificGenerator(ComplexTypeDescriptor descriptor,
java.lang.String instanceName,
boolean nullable,
Uniqueness uniqueness,
BeneratorContext context)
|
|
protected abstract Generator<?> |
TypeGeneratorFactory.createSpecificGenerator(E descriptor,
java.lang.String instanceName,
boolean nullable,
Uniqueness uniqueness,
BeneratorContext context)
|
|
protected Generator<?> |
SimpleTypeGeneratorFactory.createSpecificGenerator(SimpleTypeDescriptor descriptor,
java.lang.String instanceName,
boolean nullable,
Uniqueness uniqueness,
BeneratorContext context)
|
|
Generator<java.lang.String> |
GeneratorFactory.createStringGenerator(java.lang.String pattern,
java.util.Locale locale,
java.lang.Integer minLength,
java.lang.Integer maxLength,
int lengthGranularity,
Distribution lengthDistribution,
Uniqueness uniqueness)
|
|
static Generator<java.lang.String> |
SourceFactory.createTextLineGenerator(java.lang.String uri)
Creates a generator that iterates through the lines of a text file. |
|
static Generator<?> |
MetaGeneratorFactory.createTypeGenerator(TypeDescriptor type,
java.lang.String instanceName,
boolean nullable,
Uniqueness uniqueness,
BeneratorContext context)
|
|
protected static Generator<?> |
TypeGeneratorFactory.createValidatingGenerator(TypeDescriptor descriptor,
Generator<?> generator,
BeneratorContext context)
|
|
protected static
|
VariableGeneratorFactory.createValidatingGenerator(TypeDescriptor descriptor,
Generator<T> generator,
BeneratorContext context)
|
|
protected static Generator<?> |
SimpleTypeGeneratorFactory.createValuesGenerator(SimpleTypeDescriptor descriptor,
Uniqueness uniqueness,
BeneratorContext context)
|
|
|
SerialGeneratorFactory.createWeightedSampleGenerator(java.util.Collection<org.databene.script.WeightedSample<T>> samples,
java.lang.Class<T> targetType)
|
|
|
GeneratorFactory.createWeightedSampleGenerator(java.util.Collection<org.databene.script.WeightedSample<T>> samples,
java.lang.Class<T> targetType)
Creates a generator that chooses from a set of samples, using an individual weight for each sample. |
|
|
EquivalenceGeneratorFactory.createWeightedSampleGenerator(java.util.Collection<org.databene.script.WeightedSample<T>> samples,
java.lang.Class<T> targetType)
|
|
static Generator<java.lang.Object[]> |
SourceFactory.createXLSLineGenerator(java.lang.String uri)
Creates a generator that creates lines from a XLS file as Object arrays. |
|
static Generator<?> |
DescriptorUtil.getGeneratorByName(TypeDescriptor descriptor,
BeneratorContext context)
|
|
static
|
DescriptorUtil.processCyclic(Generator<T> generator,
TypeDescriptor descriptor)
|
|
static
|
DescriptorUtil.processOffset(Generator<T> generator,
TypeDescriptor descriptor)
|
|
static
|
VariableGeneratorFactory.wrapWithProxy(Generator<T> generator,
boolean cyclic)
|
|
static
|
VariableGeneratorFactory.wrapWithProxy(Generator<T> generator,
TypeDescriptor descriptor)
|
|
protected static
|
DescriptorUtil.wrapWithProxy(Generator<T> generator,
TypeDescriptor descriptor)
|
Methods in org.databene.benerator.factory with parameters of type Generator | ||
---|---|---|
protected Generator<?> |
ArrayTypeGeneratorFactory.applyComponentBuilders(Generator<?> generator,
ArrayTypeDescriptor descriptor,
java.lang.String instanceName,
Uniqueness uniqueness,
BeneratorContext context)
|
|
protected Generator<?> |
ComplexTypeGeneratorFactory.applyComponentBuilders(Generator<?> generator,
ComplexTypeDescriptor descriptor,
java.lang.String instanceName,
Uniqueness uniqueness,
BeneratorContext context)
|
|
protected Generator<?> |
TypeGeneratorFactory.applyComponentBuilders(Generator<?> generator,
E descriptor,
java.lang.String instanceName,
Uniqueness uniqueness,
BeneratorContext context)
|
|
Generator<?> |
StochasticGeneratorFactory.applyNullSettings(Generator<?> source,
java.lang.Boolean nullable,
java.lang.Double nullQuota)
|
|
Generator<?> |
SerialGeneratorFactory.applyNullSettings(Generator<?> source,
java.lang.Boolean nullable,
java.lang.Double nullQuota)
|
|
abstract Generator<?> |
GeneratorFactory.applyNullSettings(Generator<?> source,
java.lang.Boolean nullable,
java.lang.Double nullQuota)
|
|
Generator<?> |
EquivalenceGeneratorFactory.applyNullSettings(Generator<?> source,
java.lang.Boolean nullable,
java.lang.Double nullQuota)
|
|
protected Generator<?> |
TypeGeneratorFactory.applyRootWrappers(Generator<?> generator,
E descriptor,
java.lang.String instanceName,
Uniqueness uniqueness,
BeneratorContext context)
|
|
|
StochasticGeneratorFactory.createAlternativeGenerator(java.lang.Class<T> targetType,
Generator<T>[] sources,
Uniqueness uniqueness)
|
|
|
SerialGeneratorFactory.createAlternativeGenerator(java.lang.Class<T> targetType,
Generator<T>[] sources,
Uniqueness uniqueness)
|
|
abstract
|
GeneratorFactory.createAlternativeGenerator(java.lang.Class<T> targetType,
Generator<T>[] sources,
Uniqueness uniqueness)
|
|
|
EquivalenceGeneratorFactory.createAlternativeGenerator(java.lang.Class<T> targetType,
Generator<T>[] sources,
Uniqueness uniqueness)
|
|
|
StochasticGeneratorFactory.createCompositeArrayGenerator(java.lang.Class<T> componentType,
Generator<T>[] sources,
Uniqueness uniqueness)
|
|
|
SerialGeneratorFactory.createCompositeArrayGenerator(java.lang.Class<T> componentType,
Generator<T>[] sources,
Uniqueness uniqueness)
|
|
abstract
|
GeneratorFactory.createCompositeArrayGenerator(java.lang.Class<T> componentType,
Generator<T>[] sources,
Uniqueness uniqueness)
Creates a generator that reads products of an array of generators and combines them in an array. |
|
|
EquivalenceGeneratorFactory.createCompositeArrayGenerator(java.lang.Class<T> componentType,
Generator<T>[] sources,
Uniqueness uniqueness)
|
|
static Generator<?> |
VariableGeneratorFactory.createConvertingGenerator(TypeDescriptor descriptor,
Generator<?> generator,
BeneratorContext context)
|
|
static Generator<?> |
DescriptorUtil.createConvertingGenerator(TypeDescriptor descriptor,
Generator<?> generator,
BeneratorContext context)
|
|
static Generator<?> |
TypeGeneratorFactory.createConvertingGenerator(TypeDescriptor descriptor,
Generator generator,
BeneratorContext context)
|
|
static Generator<?> |
ComplexTypeGeneratorFactory.createMutatingEntityGenerator(java.lang.String name,
ComplexTypeDescriptor descriptor,
Uniqueness ownerUniqueness,
BeneratorContext context,
Generator<?> source)
|
|
protected static Generator<?> |
TypeGeneratorFactory.createValidatingGenerator(TypeDescriptor descriptor,
Generator<?> generator,
BeneratorContext context)
|
|
protected static
|
VariableGeneratorFactory.createValidatingGenerator(TypeDescriptor descriptor,
Generator<T> generator,
BeneratorContext context)
|
|
static
|
DescriptorUtil.processCyclic(Generator<T> generator,
TypeDescriptor descriptor)
|
|
static
|
DescriptorUtil.processOffset(Generator<T> generator,
TypeDescriptor descriptor)
|
|
static
|
VariableGeneratorFactory.wrapWithProxy(Generator<T> generator,
boolean cyclic)
|
|
static
|
VariableGeneratorFactory.wrapWithProxy(Generator<T> generator,
TypeDescriptor descriptor)
|
|
protected static
|
DescriptorUtil.wrapWithProxy(Generator<T> generator,
TypeDescriptor descriptor)
|
Uses of Generator in org.databene.benerator.file |
---|
Classes in org.databene.benerator.file that implement Generator | |
---|---|
class |
BinaryFileContentGenerator
Provides file contents as byte arrays. |
class |
FileContentGenerator<E>
Abstract parent class for generators that generate products based on concrete files. |
class |
FileGenerator
Generates File objects which represent files and/or directories in a parent directory. |
class |
FileNameGenerator
Generates file and/or directory names out of a directory. |
class |
TextFileContentGenerator
Provides file contents as String s. |
class |
XMLFileGenerator
Generates XML files. |
Methods in org.databene.benerator.file with parameters of type Generator | ||
---|---|---|
static
|
FileBuilder.build(Generator<T> generator,
int length,
org.databene.commons.DocumentWriter<T> writer)
|
Uses of Generator in org.databene.benerator.primitive |
---|
Subinterfaces of Generator in org.databene.benerator.primitive | |
---|---|
interface |
VarLengthStringGenerator
Common parent class for NonNullGenerator s that can
generate a String of a requested length. |
Classes in org.databene.benerator.primitive that implement Generator | |
---|---|
class |
BooleanGenerator
Generates boolean values with a configurable quota of true values. |
class |
CharacterGenerator
Generates Character values from a character set or a regular expression. |
class |
DynamicCountGenerator
Behaves similar to the DynamicLongGenerator ,
but generates maxFallback values, if max is set to null . |
class |
DynamicLongGenerator
Generator implementation that generates Long numbers,
redefining the underlying distribution on each reset() by
evaluating the min , max , granularity ,
distribution and unique values. |
class |
EquivalenceStringGenerator<E>
Generator which generates String s by first generating a part and a part count
and the repeating the part the generated number of times. |
class |
HibUUIDGenerator
Creates UUIDs evaluating IP address, a JVM ID and timestamp. |
class |
HiLoGenerator
Combines the output of a 'slow' generator (e.g. a remote hiGenerator) with quickly generated numbers in a range: value = hi * maxLo + local. |
class |
IncrementalIdGenerator
Generates unique long values incrementally. |
class |
IncrementalIntsGenerator
Generates int arrays in the same manner in which decimal numbers are used. |
class |
IncrementalStringGenerator
Creates Strings in an incremental manner. |
class |
IncrementGenerator
Generates long values by continuously incrementing a base (min) value. |
class |
LocalSequenceGenerator
Local implementation of an increment Generator that behaves like a database sequence. |
class |
LongGenerator
Abstract parent class for Generator s that generate Long values. |
class |
LuhnGenerator
Generates numbers that pass a Luhn test. |
class |
RandomVarLengthStringGenerator
Generates String s composed of numerical digits. |
class |
RegexStringGenerator
Generates Strings that comply to a regular expression. |
class |
ScriptGenerator
Creates Object s based on a Script. |
class |
SeedSentenceGenerator
Generates sentences based on a seed sentence set. |
class |
SeedWordGenerator
Generates words based on a word seed. |
class |
StringGenerator
String Generator which offers a wide range of options for generating strings. |
class |
TokenCombiner
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. |
protected class |
TokenCombiner.SimpleTokenCombinator
|
class |
UniqueFixedLengthStringGenerator
Generates unique strings of fixed length. |
class |
UniqueIntsGenerator
Creates unique pseudo-random int arrays. |
class |
UniqueScrambledStringGenerator
Generates unique strings of variable length. |
class |
UUIDGenerator
Creates UUIDs using UUID.randomUUID() . |
Constructors in org.databene.benerator.primitive with parameters of type Generator | |
---|---|
EquivalenceStringGenerator(Generator<E> charGenerator,
NonNullGenerator<java.lang.Integer> lengthGenerator)
|
Uses of Generator in org.databene.benerator.primitive.datetime |
---|
Classes in org.databene.benerator.primitive.datetime that implement Generator | |
---|---|
class |
CurrentDateGenerator
Generates java.util.Date objects that represent the current Date (time is 00:00:00). |
class |
CurrentDateTimeGenerator
Generates java.util.Date objects that represent the current date and time. |
class |
CurrentMilliTimeGenerator
Generates Long values that represent the current time in milliseconds. |
class |
CurrentNanoTimeGenerator
Generates Long objects that represent the current system time in nanoseconds since 1970-01-01. |
class |
CurrentTimeGenerator
Generates Date objects that represent the current time. |
class |
DateGenerator
creates date values by a LongGenerator. |
class |
DateTimeGenerator
Creates DateTimes with separate date and time distribution characteristics. |
class |
DayGenerator
Generates dates with a granularity of days, months or years. |
Uses of Generator in org.databene.benerator.primitive.number |
---|
Classes in org.databene.benerator.primitive.number that implement Generator | |
---|---|
class |
AbstractBigDecimalGenerator
Wrapper for a LongGenerator that maps the generated Longs to BigDecimals. |
class |
AbstractBigIntegerGenerator
Wrapper for a LongGenerator that maps the generated Longs to BigIntegers. |
class |
AbstractNonNullNumberGenerator<E extends Number>
Abstract parent class for all number generators. |
class |
RecurrenceRelationNumberGenerator<E extends Number>
Parent class for Number Generators that calculate numbers recursively. |
Uses of Generator in org.databene.benerator.sample |
---|
Classes in org.databene.benerator.sample that implement Generator | |
---|---|
class |
AbstractSampleGenerator<E>
Generates values from a list of samples. |
class |
AttachedWeightSampleGenerator<E>
Generates values from a weighted or non-weighted set of samples. |
class |
ConstantGenerator<E>
Generator implementation that always returns the same value. |
class |
IndividualWeightSampleGenerator<E>
Maps an IndividualWeight distribution to an AbstractWeightFunction and uses its capabilities
for providing distribution features based on the IndividualWeight 's characteristics. |
class |
NonNullSampleGenerator<E>
Generates data from a base of non-null sample values. |
class |
OneShotGenerator<E>
Returns a value only once and then becomes unavailable immediately. |
class |
SampleGenerator<E>
Generates values from a non-weighted list of samples, applying an explicitly defined distribution. |
class |
SeedGenerator<E>
Generates value sequences derived from seed sequences. |
class |
SequencedCSVSampleGenerator<E>
Sample Generator for values that are read from a CSV file. |
class |
SequenceGenerator<E>
Creates a predefined sequence of objects. |
class |
StateGenerator<E>
Generates states as configured by a state machine. |
class |
StateTransitionGenerator<E>
Generates state transitions of a state machine. |
class |
WeightedCSVSampleGenerator<E>
Sample Generator for values that are read from a CSV file. |
class |
WeigthedLiteralGenerator<E>
Generates values defined by a weighted or non-weighted value list literal, like "'A'^3,'B'^2", supporting weighted random generation and uniqueness. |
Uses of Generator in org.databene.benerator.test |
---|
Fields in org.databene.benerator.test with type parameters of type Generator | |
---|---|
protected java.lang.Class<? extends Generator> |
GeneratorClassTest.generatorClass
|
Methods in org.databene.benerator.test with type parameters of type Generator | ||
---|---|---|
|
GeneratorTest.initialize(T generator)
|
Methods in org.databene.benerator.test with parameters of type Generator | ||
---|---|---|
static void |
GeneratorTest.assertAvailable(Generator<?> generator)
|
|
static void |
GeneratorTest.assertAvailable(java.lang.String message,
Generator<?> generator)
|
|
protected void |
GeneratorClassTest.assertCustomToStringMethod(Generator<?> generator)
|
|
static void |
GeneratorTest.assertUnavailable(Generator<?> generator)
|
|
static
|
GeneratorTest.checkEqualDistribution(Generator<E> generator,
int iterations,
double tolerance,
java.util.Set<E> expectedSet)
|
|
static
|
GeneratorTest.checkProductSet(Generator<T> generator,
int iterations,
java.util.Set<T> expectedSet)
|
|
void |
GeneratorTest.close(Generator<?> generator)
|
|
static
|
GeneratorTest.countProducts(Generator<T> generator,
int n)
|
|
protected static
|
GeneratorTest.expectGeneratedSequence(Generator<T> generator,
T... products)
|
|
protected static
|
GeneratorTest.expectGeneratedSequenceOnce(Generator<T> generator,
T... products)
|
|
protected
|
GeneratorTest.expectGeneratedSet(Generator<T> generator,
int invocations,
T... products)
|
|
protected
|
GeneratorTest.expectGenerations(Generator<T> generator,
int n,
org.databene.commons.Validator... validators)
|
|
protected
|
GeneratorTest.expectRange(Generator<T> generator,
int n,
T min,
T max)
|
|
protected
|
GeneratorTest.expectRangeOnce(Generator<T> generator,
int n,
T min,
T max)
|
|
protected static void |
GeneratorTest.expectRelativeWeights(Generator<?> generator,
int iterations,
java.lang.Object... expectedValueWeightPairs)
|
|
protected
|
GeneratorTest.expectUniqueGenerations(Generator<T> generator,
int n)
|
|
protected
|
GeneratorTest.expectUniquelyGeneratedSet(Generator<T> generator,
T... products)
|
|
protected
|
GeneratorTest.expectUniqueProducts(Generator<T> generator,
int n)
|
|
void |
GeneratorTest.printProducts(Generator<?> generator,
int n)
|
Constructors in org.databene.benerator.test with parameters of type Generator | |
---|---|
GeneratorTest.Helper(Generator<?> generator)
|
Constructor parameters in org.databene.benerator.test with type arguments of type Generator | |
---|---|
GeneratorClassTest(java.lang.Class<? extends Generator> generatorClass)
|
Uses of Generator in org.databene.benerator.util |
---|
Classes in org.databene.benerator.util that implement Generator | |
---|---|
class |
AbstractGenerator<E>
Abstract Generator implementation which holds a state and state management methods. |
class |
AbstractNonNullGenerator<E>
Abstract implementation of the NonNullGenerator. |
class |
ExpressionBasedGenerator<E>
Evaluates an Expression on each call to ExpressionBasedGenerator.generate(ProductWrapper)
and returns its results. |
class |
FilteringGenerator<E>
Generator proxy which takes the input of another Generator and only passes it if a boolean expression evaluates to true. |
class |
SharedGenerator<E>
Proxy for generators that are used by several clients. |
class |
ThreadSafeGenerator<E>
Parent class for Generators which are thread-safe. |
class |
ThreadSafeNonNullGenerator<E>
NonNullGenerator implementation which declares thread safety. |
class |
UnsafeGenerator<E>
Abstract parent class for Generator s that are neither thread-safe nor parallelizable. |
class |
UnsafeMethodParamsGenerator
Parent class for Generator implementations that
create method parameters as Object arrays. |
class |
UnsafeNonNullGenerator<E>
NonNullGenerator implementation which declares that it is neither thread-safe nor parallelizable. |
class |
ValidatingGenerator<P>
Provides an abstract implementation of a generator that validates its generated values. |
Fields in org.databene.benerator.util declared as Generator | |
---|---|
protected Generator<G> |
GeneratingConverter.generator
|
Methods in org.databene.benerator.util that return Generator | |
---|---|
static Generator<?> |
GeneratorUtil.unwrap(Generator<?> generator)
|
Methods in org.databene.benerator.util with parameters of type Generator | ||
---|---|---|
static
|
GeneratorUtil.allProducts(Generator<T> generator)
|
|
static void |
GeneratorUtil.close(Generator<?> generator)
|
|
static
|
GeneratorUtil.commonTargetTypeOf(Generator<T>... sources)
|
|
protected E |
GeneratorIterator.fetchNext(Generator<E> source)
|
|
static
|
GeneratorUtil.generateNonNull(Generator<T> generator)
Calls a Generator 's generate(ProductWrapper) method and returns its unwrapped result,
signaling generator unavailability with a null value and requiring the Generator
not to create null values as result. |
|
static
|
GeneratorUtil.generateNullable(Generator<T> generator)
Calls a Generator 's generate(ProductWrapper) method and returns its unwrapped result,
allowing null |
|
static void |
GeneratorUtil.init(Generator<?> generator)
|
|
static void |
GeneratorUtil.init(Generator<?> generator,
GeneratorContext context)
|
|
static void |
GeneratorUtil.initAll(Generator<?>[] generators,
GeneratorContext context)
|
|
static Generator<?> |
GeneratorUtil.unwrap(Generator<?> generator)
|
Constructors in org.databene.benerator.util with parameters of type Generator | |
---|---|
FilteringGenerator(Generator<E> source,
org.databene.script.Expression<java.lang.Boolean> filter)
|
|
GeneratingConverter(java.lang.Class<S> sourceType,
java.lang.Class<T> targetType,
Generator<G> generator)
|
|
GeneratorIterator(Generator<E> source)
|
|
SharedGenerator(Generator<E> source)
|
Uses of Generator in org.databene.benerator.wrapper |
---|
Classes in org.databene.benerator.wrapper that implement Generator | |
---|---|
class |
AccessingGenerator<S,P>
Returns the results of an accessor that is applied on a constant provider object. |
class |
AlternativeGenerator<E>
On each call to generate(), it chooses a generator from a collection, calls its generate() method and returns the product. |
class |
AsBigDecimalGeneratorWrapper<E extends Number>
Converts the Number products of another Generator to BigDecimal . |
class |
AsBigIntegerGeneratorWrapper<E extends Number>
Converts the Number products of another Generator to BigInteger . |
class |
AsByteGeneratorWrapper<E extends Number>
Converts the Number products of another Generator to Byte . |
class |
AsDoubleGeneratorWrapper<E extends Number>
Double Generator that maps products from a generator of a different number type. |
class |
AsFloatGeneratorWrapper<E extends Number>
Converts the Number products of another Generator to Float . |
class |
AsIntegerGeneratorWrapper<E extends Number>
Converts the Number products of another Generator to Integer . |
class |
AsLongGeneratorWrapper<E extends Number>
Long Generator that maps products from a Double generator. |
class |
AsNonNullGenerator<E>
Adapter class which makes an arbitrary Generator available as NonNullGenerator . |
class |
AsShortGeneratorWrapper<E extends Number>
Converts the Number products of another Generator to Short . |
class |
AsStringGenerator<E>
Wraps another Generator and converts its products to String s. |
class |
ByteArrayGenerator
Creates arrays of random length filled with random bytes. |
class |
CardinalGenerator<S,P>
Combines a a random number a source generator's products into a collection. |
class |
CollectionGenerator<C extends Collection,I>
Combines a a random number a source generator's products into a collection. |
class |
CompositeGenerator<E>
Generator implementation that makes use of other ContextAware
objects by which its threading support is influenced. |
class |
CompositeStringGenerator
Uses n String generators and appends the output of each one in each generate() call. |
class |
ConcatenatingGenerator
Generator implementation that wraps several String generators
and concatenates their results to a composite String . |
class |
ConvertingGenerator<S,T>
Reads products from a source Generator and applies a Converter to transform them into the target products. |
class |
CyclicGeneratorProxy<E>
Generator proxy that 'loops' through a source Generator, calling reset() each time the source becomes unavailable. |
class |
DataSourceGenerator<E>
Generator implementation which reads and forwards data from a DataSource . |
class |
GeneratorChain<E>
Proxies several source generators, initially returning products of the first source as long as it is available, then of the second source and son on. |
class |
GeneratorProxy<E>
Wraps another Generator of same product type. |
class |
GeneratorWrapper<S,P>
Abstract generator class that wraps another generator object (in a source property) and delegates life cycle control to it. |
class |
IteratingGenerator<E>
Iterates over Iterators that are provided by an Iterable . |
class |
LastFlagGenerator
Proxies a Generator , examines its generated ProductWrapper s for the "last" tag and, if one is found,
replaces a boolean array value at a given index (LastFlagGenerator.indexOfLastFlag ) with true, otherwise with false. |
class |
LastProductDetector<E>
Wraps another Generator , finds out which is the last generated object and tags that with "last"="true". |
class |
LengthGenerator<S,P>
Abstract parent class for Generator s that generate objects of a variable length. |
class |
MessageGenerator
Assembles the output of several source generators by a java.text.MessageFormat. |
class |
MultiGeneratorWrapper<S,P>
Parent class for wrapping several other generators (in a sources property) and refining a composite state from them. |
class |
MultiSourceArrayGenerator<S>
Keeps an array of generators, of which it combines the products to an array. |
class |
NonClosingGeneratorProxy<E>
Generator proxy that prevents its delegate from being closed. |
class |
NonNullGeneratorProxy<E>
GeneratorProxy implementation which implements the NonNullGenerator interface and
supports its implementors as source Generator . |
class |
NonNullGeneratorWrapper<S,P>
GeneratorWrapper for NonNullGenerator s. |
class |
NShotGeneratorProxy<E>
Generator proxy which forwards a limited number of products from another generator. |
class |
NullInjectingGeneratorProxy<E>
GeneratorProxy implementation which injects a given quota of null values in the
original generator's results. |
class |
NullStartingGenerator<E>
Generator implementation which wraps a source Generator
but generates a null value before forwarding the products of the source. |
class |
OffsetBasedGenerator<E>
Generator proxy which hides the first products of its source generator. |
class |
RepeatGeneratorProxy<E>
A generator proxy that forwards the output of another generator with a random number of repetitions. |
class |
SimpleMultiSourceArrayGenerator<S>
Keeps an array of generators, of which it combines the products to an array. |
class |
SingleSourceArrayGenerator<S,P>
Assembles the output of a source generator into an array of random length. |
class |
SingleSourceCollectionGenerator<I,C extends Collection<I>>
Generator which takes one or more products from a source generator and wraps them with a Collection . |
class |
SkipGeneratorProxy<E>
This forwards a source generator's products. |
class |
SynchronizedGeneratorProxy<E>
Synchronized wrapper class for non-thread-safe Generator implementations. |
class |
UniqueMultiSourceArrayGenerator<S>
Creates arrays of unique combinations of the output of other generators. |
class |
ValidatingGeneratorProxy<E>
Generator proxy that uses another generator for creating values and filters out invalid ones. |
class |
WeighingGeneratorWrapper<E>
Wraps an ordinary Generator with a WeightedGenerator interface
requiring an explicit weight setting. |
class |
WeightedGeneratorGenerator<E>
Generator that wraps several other 'source generators' and assigns a weight to each one. |
Fields in org.databene.benerator.wrapper with type parameters of type Generator | |
---|---|
protected java.util.List<Generator<? extends S>> |
MultiGeneratorWrapper.sources
|
Methods in org.databene.benerator.wrapper with type parameters of type Generator | ||
---|---|---|
protected
|
CompositeGenerator.registerComponent(T component)
|
Methods in org.databene.benerator.wrapper that return Generator | ||
---|---|---|
static
|
WrapperFactory.applyConverter(Generator<S> source,
org.databene.commons.Converter... converter)
Creates a generator that accepts products from a source generator and converts them to target products by the converter |
|
static
|
WrapperFactory.applyCycler(Generator<T> generator)
|
|
static
|
WrapperFactory.applyHeadCycler(Generator<T> source)
|
|
static
|
WrapperFactory.applyLastProductDetector(Generator<T> generator)
|
|
static
|
WrapperFactory.applyValidator(org.databene.commons.Validator<T> validator,
Generator<T> generator)
|
|
static
|
WrapperFactory.asNumberGeneratorOfType(java.lang.Class<T> numberType,
Generator<? extends java.lang.Number> source,
T min,
T granularity)
|
|
static Generator<java.lang.String> |
WrapperFactory.asStringGenerator(Generator<?> source)
|
|
static Generator<java.lang.String>[] |
WrapperFactory.asStringGenerators(Generator<?>[] sources)
|
|
static Generator<java.lang.String> |
WrapperFactory.createMessageGenerator(java.lang.String pattern,
int minLength,
int maxLength,
Generator... sources)
Creates a generator that generates messages by reading the products of several source generators and combining them by a Java MessageFormat. |
|
protected Generator<? extends S> |
MultiGeneratorWrapper.getAvailableSource(int index)
|
|
Generator<S> |
GeneratorWrapper.getSource()
Returns the source generator |
|
Generator<? extends S> |
MultiGeneratorWrapper.getSource(int index)
|
|
Generator<? extends S>[] |
MultiSourceArrayGenerator.getSources()
|
|
static
|
WrapperFactory.injectNulls(Generator<T> source,
double nullQuota)
|
|
static
|
WrapperFactory.prependNull(Generator<T> source)
|
|
static
|
WrapperFactory.preventClosing(Generator<T> generator)
|
|
protected static Generator<java.lang.String[]> |
CompositeStringGenerator.wrap(boolean unique,
Generator<?>... sources)
|
Methods in org.databene.benerator.wrapper that return types with arguments of type Generator | |
---|---|
ProductWrapper<Generator<E>> |
WeightedGeneratorGenerator.generate(ProductWrapper<Generator<E>> wrapper)
|
java.util.List<Generator<? extends S>> |
MultiGeneratorWrapper.getSources()
|
Methods in org.databene.benerator.wrapper with parameters of type Generator | ||
---|---|---|
void |
WeightedGeneratorGenerator.addSource(Generator<? extends E> source)
|
|
void |
WeightedGeneratorGenerator.addSource(Generator<? extends E> source,
java.lang.Double weight)
|
|
void |
MultiGeneratorWrapper.addSource(Generator<? extends S> source)
|
|
static
|
WrapperFactory.applyConverter(Generator<S> source,
org.databene.commons.Converter... converter)
Creates a generator that accepts products from a source generator and converts them to target products by the converter |
|
static
|
WrapperFactory.applyCycler(Generator<T> generator)
|
|
static
|
WrapperFactory.applyHeadCycler(Generator<T> source)
|
|
static
|
WrapperFactory.applyLastProductDetector(Generator<T> generator)
|
|
static
|
WrapperFactory.applyOffset(Generator<T> generator,
int offset)
|
|
static
|
WrapperFactory.applyValidator(org.databene.commons.Validator<T> validator,
Generator<T> generator)
|
|
static
|
WrapperFactory.asNonNullGenerator(Generator<T> source)
|
|
static
|
WrapperFactory.asNumberGeneratorOfType(java.lang.Class<T> numberType,
Generator<? extends java.lang.Number> source,
T min,
T granularity)
|
|
static Generator<java.lang.String> |
WrapperFactory.asStringGenerator(Generator<?> source)
|
|
static Generator<java.lang.String>[] |
WrapperFactory.asStringGenerators(Generator<?>[] sources)
|
|
protected static
|
AsStringGenerator.createConverter(Generator<T> source)
|
|
static Generator<java.lang.String> |
WrapperFactory.createMessageGenerator(java.lang.String pattern,
int minLength,
int maxLength,
Generator... sources)
Creates a generator that generates messages by reading the products of several source generators and combining them by a Java MessageFormat. |
|
static
|
WrapperFactory.injectNulls(Generator<T> source,
double nullQuota)
|
|
static
|
WrapperFactory.prependNull(Generator<T> source)
|
|
static
|
WrapperFactory.preventClosing(Generator<T> generator)
|
|
void |
NonNullGeneratorProxy.setSource(Generator<E> source)
Sets the source generator |
|
void |
GeneratorWrapper.setSource(Generator<S> source)
Sets the source generator |
|
void |
MessageGenerator.setSources(Generator<?>[] sources)
Sets the source generators |
|
void |
MultiSourceArrayGenerator.setSources(Generator<? extends S>[] sources)
|
|
void |
CompositeStringGenerator.setSources(Generator<java.lang.String>[] sources)
|
|
protected static Generator<java.lang.String[]> |
CompositeStringGenerator.wrap(boolean unique,
Generator<?>... sources)
|
Method parameters in org.databene.benerator.wrapper with type arguments of type Generator | |
---|---|
ProductWrapper<Generator<E>> |
WeightedGeneratorGenerator.generate(ProductWrapper<Generator<E>> wrapper)
|
void |
MultiGeneratorWrapper.setSources(java.util.List<Generator<? extends S>> sources)
|
Constructors in org.databene.benerator.wrapper with parameters of type Generator | |
---|---|
AlternativeGenerator(java.lang.Class<E> targetType,
Generator<E>... sources)
Initializes the generator to a collection of source generators |
|
AsBigDecimalGeneratorWrapper(Generator<E> source)
|
|
AsBigDecimalGeneratorWrapper(Generator<E> source,
java.math.BigDecimal min,
java.math.BigDecimal granularity)
|
|
AsBigIntegerGeneratorWrapper(Generator<E> source)
|
|
AsByteGeneratorWrapper(Generator<E> source)
|
|
AsDoubleGeneratorWrapper(Generator<E> source)
|
|
AsFloatGeneratorWrapper(Generator<E> source)
|
|
AsIntegerGeneratorWrapper(Generator<E> source)
|
|
AsLongGeneratorWrapper(Generator<E> source)
|
|
AsNonNullGenerator(Generator<E> source)
|
|
AsShortGeneratorWrapper(Generator<E> source)
|
|
AsStringGenerator(Generator<E> source)
|
|
ByteArrayGenerator(Generator<java.lang.Byte> source,
int minLength,
int maxLength)
|
|
ByteArrayGenerator(Generator<java.lang.Byte> source,
int minLength,
int maxLength,
Distribution distribution)
|
|
CardinalGenerator(Generator<S> source,
boolean resettingCardinalGenerator)
|
|
CardinalGenerator(Generator<S> source,
boolean resettingCardinalGenerator,
int minCardinal,
int maxCardinal,
int cardinalGranularity,
Distribution cardinalDistribution)
|
|
CardinalGenerator(Generator<S> source,
boolean resettingCardinal,
NonNullGenerator<java.lang.Integer> cardinalGenerator)
|
|
CollectionGenerator(java.lang.Class<C> collectionType,
Generator<I> source,
int minSize,
int maxSize,
Distribution sizeDistribution)
|
|
CompositeStringGenerator(boolean unique,
Generator<java.lang.String>... sources)
|
|
ConcatenatingGenerator(Generator<java.lang.String[]> source)
|
|
ConcatenatingGenerator(Generator<java.lang.String[]> source,
java.lang.String separator)
|
|
ConvertingGenerator(Generator<S> source,
org.databene.commons.Converter<?,?>... converters)
Initializes all attributes |
|
CyclicGeneratorProxy(Generator<E> source)
|
|
GeneratorChain(java.lang.Class<E> generatedType,
boolean unique,
Generator<? extends E>... sources)
|
|
GeneratorProxy(Generator<E> source)
|
|
GeneratorWrapper(Generator<S> source)
|
|
LastFlagGenerator(Generator<java.lang.Object[]> source,
int indexOfLastFlag)
|
|
LastProductDetector(Generator<E> source)
|
|
LengthGenerator(Generator<S> source,
boolean resettingLengthGenerator)
|
|
LengthGenerator(Generator<S> source,
boolean resettingLengthGenerator,
int minLength,
int maxLength,
int lengthGranularity,
Distribution lengthDistribution)
|
|
LengthGenerator(Generator<S> source,
boolean resettingLength,
NonNullGenerator<java.lang.Integer> lengthGenerator)
|
|
MessageGenerator(java.lang.String pattern,
Generator<?>... sources)
|
|
MessageGenerator(java.lang.String pattern,
int minLength,
int maxLength,
Generator<?>... sources)
Initializes Generator |
|
MultiGeneratorWrapper(java.lang.Class<P> generatedType,
Generator<? extends S>... sources)
|
|
MultiSourceArrayGenerator(java.lang.Class<S> componentType,
boolean unique,
Generator<? extends S>... sources)
|
|
NonClosingGeneratorProxy(Generator<E> source)
|
|
NShotGeneratorProxy(Generator<E> source,
long shots)
|
|
NullInjectingGeneratorProxy(Generator<E> source,
double nullQuota)
|
|
NullStartingGenerator(Generator<E> source)
|
|
OffsetBasedGenerator(Generator<E> source,
int offset)
|
|
RepeatGeneratorProxy(Generator<E> source,
int minRepetitions,
int maxRepetitions)
|
|
RepeatGeneratorProxy(Generator<E> source,
int minRepetitions,
int maxRepetitions,
int repetitionGranularity,
Distribution repetitionDistribution)
|
|
SimpleMultiSourceArrayGenerator(java.lang.Class<S> componentType,
Generator<? extends S>... sources)
Initializes the generator to an array of source generators |
|
SingleSourceArrayGenerator(Generator<S> source,
java.lang.Class<S> componentType,
int minLength,
int maxLength,
Distribution lengthDistribution)
|
|
SingleSourceArrayGenerator(Generator<S> source,
java.lang.Class<S> componentType,
NonNullGenerator<java.lang.Integer> lengthGenerator)
|
|
SingleSourceCollectionGenerator(Generator<I> source,
java.lang.Class<C> collectionType,
NonNullGenerator<java.lang.Integer> lengthGenerator)
|
|
SkipGeneratorProxy(Generator<E> source)
Initializes the generator to iterate with increment 1 |
|
SkipGeneratorProxy(Generator<E> source,
java.lang.Integer minIncrement,
java.lang.Integer maxIncrement)
Initializes the generator to use a random increment of uniform distribution |
|
SkipGeneratorProxy(Generator<E> source,
int minIncrement,
int maxIncrement,
Distribution incrementDistribution,
java.lang.Integer limit)
Initializes the generator to use a random increment of uniform distribution |
|
UniqueMultiSourceArrayGenerator(java.lang.Class<S> componentType,
Generator<? extends S>... sources)
Initializes the generator to an array of source generators |
|
ValidatingGeneratorProxy(Generator<E> source,
org.databene.commons.Validator<E> validator)
Constructor with the source generator and the validator to use |
|
WeighingGeneratorWrapper(Generator<E> source,
double weight)
|
Constructor parameters in org.databene.benerator.wrapper with type arguments of type Generator | |
---|---|
MultiGeneratorWrapper(java.lang.Class<P> generatedType,
java.util.List<Generator<? extends S>> sources)
|
|
UniqueMultiSourceArrayGenerator(java.lang.Class<S> componentType,
java.util.List<Generator<? extends S>> sources)
|
Uses of Generator in org.databene.domain.address |
---|
Classes in org.databene.domain.address that implement Generator | |
---|---|
class |
AddressGenerator
Generates Address objects. |
class |
CityGenerator
Generates City objects. |
class |
CountryGenerator
Generates a random country. |
class |
MobileNumberGenerator
Generates mobile phone numbers. |
class |
PhoneNumberGenerator
Generates landline or mobile phone numbers in a given Country . |
class |
StreetNameGenerator
Generates a street name for a region. |
Uses of Generator in org.databene.domain.br |
---|
Classes in org.databene.domain.br that implement Generator | |
---|---|
class |
CNPJGenerator
Generates Brazilian CNPJ numbers. |
class |
CPFGenerator
Generates Brazilian CPF numbers. |
Uses of Generator in org.databene.domain.finance |
---|
Classes in org.databene.domain.finance that implement Generator | |
---|---|
class |
BankAccountGenerator
Generates German BankAccount s with low validity requirements. |
class |
BankGenerator
Generates BankAccount s with low validity requirements. |
class |
CreditCardNumberGenerator
Creates credit card numbers. |
Uses of Generator in org.databene.domain.lang |
---|
Classes in org.databene.domain.lang that implement Generator | |
---|---|
class |
NounGenerator
Generates Noun s of a given Locale . |
Uses of Generator in org.databene.domain.math |
---|
Classes in org.databene.domain.math that implement Generator | |
---|---|
class |
FibonacciLongGenerator
Generates Fibonacci Numbers. |
class |
PadovanLongGenerator
Generates numbers according to the Padovan Sequence. |
Uses of Generator in org.databene.domain.net |
---|
Classes in org.databene.domain.net that implement Generator | |
---|---|
class |
CompanyDomainGenerator
Generates web domains for companies. |
class |
DomainGenerator
Creates Internet domains of companies, web mailers or random characters. |
class |
RandomDomainGenerator
Creates an Internet domain name from random characters. |
class |
TopLevelDomainGenerator
A TopLevelDomainGenerator. |
class |
WebmailDomainGenerator
A WebmailDomainGenerator. |
Uses of Generator in org.databene.domain.organization |
---|
Classes in org.databene.domain.organization that implement Generator | |
---|---|
class |
CompanyNameGenerator
Generates company names. |
class |
DepartmentNameGenerator
Creates random department names based on a Locale -specific CSV file. |
class |
LegalFormGenerator
Generates the abbreviated strings for legal forms of organizations. |
class |
SectorGenerator
Generator implementation which creates names of industry sectors. |
Fields in org.databene.domain.organization with type parameters of type Generator | |
---|---|
protected static java.util.Map<java.lang.String,Generator<java.lang.String>> |
CompanyNameGenerator.locationGenerators
|
Uses of Generator in org.databene.domain.person |
---|
Classes in org.databene.domain.person that implement Generator | |
---|---|
class |
AcademicTitleGenerator
Creates a quota of academic titles. |
class |
BirthDateGenerator
Creates Date objects for a person's birth day. |
class |
EMailAddressGenerator
Generates EMail Addresses. |
class |
FamilyNameGenerator
Generates family names. |
class |
GenderGenerator
Generates Gender objects. |
class |
GivenNameGenerator
Generates a given name for a person. |
class |
NobilityTitleGenerator
Creates nobility titles at a defined quota. |
class |
PersonGenerator
Generates Person beans. |
class |
TINGenerator
Generates European Tax Identification Numbers (like the German 'Steueridentifikationsnummer'). |
Methods in org.databene.domain.person with type parameters of type Generator | ||
---|---|---|
protected
|
PersonGenerator.registerAndInitComponent(T generator)
|
Methods in org.databene.domain.person that return Generator | |
---|---|
static Generator<java.lang.String> |
FamilyNameGenerator.sharedInstance(java.lang.String datasetName)
|
static Generator<java.lang.String> |
GivenNameGenerator.sharedInstance(java.lang.String datasetName,
Gender gender)
|
Uses of Generator in org.databene.domain.product |
---|
Classes in org.databene.domain.product that implement Generator | |
---|---|
class |
EAN13Generator
Generates 13-digits EAN codes. |
class |
EAN8Generator
Generates 8-digit EAN codes. |
class |
EANGenerator
Generates EAN8 and EAN13 codes at the configured ratio. |
Uses of Generator in org.databene.domain.us |
---|
Classes in org.databene.domain.us that implement Generator | |
---|---|
class |
SSNGenerator
Generates US Social Security Numbers. |
Uses of Generator in org.databene.platform.db |
---|
Classes in org.databene.platform.db that implement Generator | |
---|---|
class |
AbstractSequenceGenerator
Abstract parent class for database-sequence-related Generator s. |
class |
CachedSequenceGenerator
Reads the current value of a sequence on first invocation, increases the value locally on subsequent calls and finally (on close()) updates the DB sequence with the local value. |
class |
DBSeqHiLoGenerator
Generates Long values with a HiLo strategy using a database sequence for the Hi values. |
class |
DBSequenceGenerator
Generates Long values from a database sequence. |
class |
PlainSequenceGenerator
Generator implementation which provides sequence values from a database. |
class |
QueryGenerator<E>
Generates values based on a database query. |
class |
QueryHiLoGenerator
* Creates Unique keys efficiently by connecting a database, retrieving a (unique) sequence value and building sub keys of it. |
class |
QueryLongGenerator
Generates Long values based on a database query. |
class |
SequenceTableGenerator<E extends Number>
Uses a database table to fetch and increment values like a database sequence. |
|
||||||||||
PREV NEXT | FRAMES NO FRAMES |