Uses of Interface
org.databene.benerator.Generator

Packages that use Generator
org.databene.benerator The root package for the databene-generator library. 
org.databene.benerator.anno   
org.databene.benerator.composite   
org.databene.benerator.csv Provides String generators that parse CSV sources. 
org.databene.benerator.dataset   
org.databene.benerator.distribution   
org.databene.benerator.distribution.sequence   
org.databene.benerator.engine   
org.databene.benerator.engine.expression   
org.databene.benerator.engine.parser.xml   
org.databene.benerator.engine.statement   
org.databene.benerator.factory   
org.databene.benerator.file   
org.databene.benerator.primitive Implements Generators for simple Java types. 
org.databene.benerator.primitive.datetime   
org.databene.benerator.primitive.number Defines a small framework for generating numbers of all built-in Java number types (byte, short, int, long, BigInteger, float, double, BigDecimal) resulting from a sequence or being distributed according a distribution function. 
org.databene.benerator.sample Provides Generators that are based on collections of samples. 
org.databene.benerator.test   
org.databene.benerator.util Provides utility classes for data generation. 
org.databene.benerator.wrapper Defines generators that wrap other generators and forward or convert their products 
org.databene.domain.address databene domain for address data. 
org.databene.domain.br   
org.databene.domain.finance   
org.databene.domain.lang   
org.databene.domain.math   
org.databene.domain.net   
org.databene.domain.organization   
org.databene.domain.person databene domain for Person data. 
org.databene.domain.product   
org.databene.domain.us   
org.databene.platform.db platform adapter for databases. 
 

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 Generators 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 Generators which can generate data with and for dedicated sub sets.
 interface WeightedDatasetGenerator<E>
          Parent interface for DatasetBasedGenerators 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
<T> Generator<T>
Sequence.applyTo(Generator<T> source, boolean unique)
           
<T> Generator<T>
IndividualWeight.applyTo(Generator<T> source, boolean unique)
           
<T> Generator<T>
Distribution.applyTo(Generator<T> source, boolean unique)
           
<T> Generator<T>
CumulativeDistributionFunction.applyTo(Generator<T> source, boolean unique)
           
<T> Generator<T>
AbstractWeightFunction.applyTo(Generator<T> source, boolean unique)
           
 

Methods in org.databene.benerator.distribution with parameters of type Generator
<T> Generator<T>
Sequence.applyTo(Generator<T> source, boolean unique)
           
<T> Generator<T>
IndividualWeight.applyTo(Generator<T> source, boolean unique)
           
<T> Generator<T>
Distribution.applyTo(Generator<T> source, boolean unique)
           
<T> Generator<T>
CumulativeDistributionFunction.applyTo(Generator<T> source, boolean unique)
           
<T> Generator<T>
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 BigDecimals 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
<T> Generator<T>
WeightedNumbers.applyTo(Generator<T> source, boolean unique)
           
<T> Generator<T>
StepSequence.applyTo(Generator<T> source, boolean unique)
           
<T> Generator<T>
RepeatSequence.applyTo(Generator<T> source, boolean unique)
           
<T> Generator<T>
RandomWalkSequence.applyTo(Generator<T> source, boolean unique)
           
<T> Generator<T>
RandomSequence.applyTo(Generator<T> source, boolean unique)
           
<T> Generator<T>
HeadSequence.applyTo(Generator<T> source, boolean unique)
           
<T> Generator<T>
ExpandSequence.applyTo(Generator<T> source, boolean unique)
           
 

Methods in org.databene.benerator.distribution.sequence with parameters of type Generator
<T> Generator<T>
WeightedNumbers.applyTo(Generator<T> source, boolean unique)
           
<T> Generator<T>
StepSequence.applyTo(Generator<T> source, boolean unique)
           
<T> Generator<T>
RepeatSequence.applyTo(Generator<T> source, boolean unique)
           
<T> Generator<T>
RandomWalkSequence.applyTo(Generator<T> source, boolean unique)
           
<T> Generator<T>
RandomSequence.applyTo(Generator<T> source, boolean unique)
           
<T> Generator<T>
HeadSequence.applyTo(Generator<T> source, boolean unique)
           
<T> Generator<T>
ExpandSequence.applyTo(Generator<T> source, boolean unique)
           
static
<T> ExpandGeneratorProxy<T>
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)
           
<T> Generator<T>
StochasticGeneratorFactory.createAlternativeGenerator(java.lang.Class<T> targetType, Generator<T>[] sources, Uniqueness uniqueness)
           
<T> Generator<T>
SerialGeneratorFactory.createAlternativeGenerator(java.lang.Class<T> targetType, Generator<T>[] sources, Uniqueness uniqueness)
           
abstract
<T> Generator<T>
GeneratorFactory.createAlternativeGenerator(java.lang.Class<T> targetType, Generator<T>[] sources, Uniqueness uniqueness)
           
<T> Generator<T>
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)
           
<T> Generator<T[]>
StochasticGeneratorFactory.createCompositeArrayGenerator(java.lang.Class<T> componentType, Generator<T>[] sources, Uniqueness uniqueness)
           
<T> Generator<T[]>
SerialGeneratorFactory.createCompositeArrayGenerator(java.lang.Class<T> componentType, Generator<T>[] sources, Uniqueness uniqueness)
           
abstract
<T> Generator<T[]>
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.
<T> Generator<T[]>
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)
           
<T> Generator<T>
StochasticGeneratorFactory.createFromWeightedLiteralList(java.lang.String valueSpec, java.lang.Class<T> targetType, Distribution distribution, boolean unique)
           
<T> Generator<T>
SerialGeneratorFactory.createFromWeightedLiteralList(java.lang.String valueSpec, java.lang.Class<T> targetType, Distribution distribution, boolean unique)
           
abstract
<T> Generator<T>
GeneratorFactory.createFromWeightedLiteralList(java.lang.String valueSpec, java.lang.Class<T> targetType, Distribution distribution, boolean unique)
           
<T> Generator<T>
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)
           
<T> Generator<T>
StochasticGeneratorFactory.createNullGenerator(java.lang.Class<T> generatedType)
           
<T> Generator<T>
SerialGeneratorFactory.createNullGenerator(java.lang.Class<T> generatedType)
           
abstract
<T> Generator<T>
GeneratorFactory.createNullGenerator(java.lang.Class<T> generatedType)
           
<T> Generator<T>
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
<T> Generator<T>
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)
           
<T> Generator<T>
StochasticGeneratorFactory.createSampleGenerator(java.util.Collection<T> values, java.lang.Class<T> generatedType, boolean unique)
           
<T> Generator<T>
SerialGeneratorFactory.createSampleGenerator(java.util.Collection<T> values, java.lang.Class<T> generatedType, boolean unique)
           
abstract
<T> Generator<T>
GeneratorFactory.createSampleGenerator(java.util.Collection<T> values, java.lang.Class<T> generatedType, boolean unique)
           
<T> Generator<T>
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)
           
<T> Generator<T>
StochasticGeneratorFactory.createSingleValueGenerator(T value, boolean unique)
           
<T> Generator<T>
SerialGeneratorFactory.createSingleValueGenerator(T value, boolean unique)
           
abstract
<T> Generator<T>
GeneratorFactory.createSingleValueGenerator(T value, boolean unique)
          Creates a generator that returns a single value.
<T> Generator<T>
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
<T> Generator<T>
VariableGeneratorFactory.createValidatingGenerator(TypeDescriptor descriptor, Generator<T> generator, BeneratorContext context)
           
protected static Generator<?> SimpleTypeGeneratorFactory.createValuesGenerator(SimpleTypeDescriptor descriptor, Uniqueness uniqueness, BeneratorContext context)
           
<T> Generator<T>
SerialGeneratorFactory.createWeightedSampleGenerator(java.util.Collection<org.databene.script.WeightedSample<T>> samples, java.lang.Class<T> targetType)
           
<T> Generator<T>
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.
<T> Generator<T>
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
<T> Generator<T>
DescriptorUtil.processCyclic(Generator<T> generator, TypeDescriptor descriptor)
           
static
<T> Generator<T>
DescriptorUtil.processOffset(Generator<T> generator, TypeDescriptor descriptor)
           
static
<T> Generator<T>
VariableGeneratorFactory.wrapWithProxy(Generator<T> generator, boolean cyclic)
           
static
<T> Generator<T>
VariableGeneratorFactory.wrapWithProxy(Generator<T> generator, TypeDescriptor descriptor)
           
protected static
<T> Generator<T>
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)
           
<T> Generator<T>
StochasticGeneratorFactory.createAlternativeGenerator(java.lang.Class<T> targetType, Generator<T>[] sources, Uniqueness uniqueness)
           
<T> Generator<T>
SerialGeneratorFactory.createAlternativeGenerator(java.lang.Class<T> targetType, Generator<T>[] sources, Uniqueness uniqueness)
           
abstract
<T> Generator<T>
GeneratorFactory.createAlternativeGenerator(java.lang.Class<T> targetType, Generator<T>[] sources, Uniqueness uniqueness)
           
<T> Generator<T>
EquivalenceGeneratorFactory.createAlternativeGenerator(java.lang.Class<T> targetType, Generator<T>[] sources, Uniqueness uniqueness)
           
<T> Generator<T[]>
StochasticGeneratorFactory.createCompositeArrayGenerator(java.lang.Class<T> componentType, Generator<T>[] sources, Uniqueness uniqueness)
           
<T> Generator<T[]>
SerialGeneratorFactory.createCompositeArrayGenerator(java.lang.Class<T> componentType, Generator<T>[] sources, Uniqueness uniqueness)
           
abstract
<T> Generator<T[]>
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.
<T> Generator<T[]>
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
<T> Generator<T>
VariableGeneratorFactory.createValidatingGenerator(TypeDescriptor descriptor, Generator<T> generator, BeneratorContext context)
           
static
<T> Generator<T>
DescriptorUtil.processCyclic(Generator<T> generator, TypeDescriptor descriptor)
           
static
<T> Generator<T>
DescriptorUtil.processOffset(Generator<T> generator, TypeDescriptor descriptor)
           
static
<T> Generator<T>
VariableGeneratorFactory.wrapWithProxy(Generator<T> generator, boolean cyclic)
           
static
<T> Generator<T>
VariableGeneratorFactory.wrapWithProxy(Generator<T> generator, TypeDescriptor descriptor)
           
protected static
<T> Generator<T>
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 Strings.
 class XMLFileGenerator
          Generates XML files.
 

Methods in org.databene.benerator.file with parameters of type Generator
static
<T> void
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 NonNullGenerators 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 Strings 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 Generators that generate Long values.
 class LuhnGenerator
          Generates numbers that pass a Luhn test.
 class RandomVarLengthStringGenerator
          Generates Strings composed of numerical digits.
 class RegexStringGenerator
          Generates Strings that comply to a regular expression.
 class ScriptGenerator
          Creates Objects 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
<T extends Generator<U>,U>
T
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
<E> void
GeneratorTest.checkEqualDistribution(Generator<E> generator, int iterations, double tolerance, java.util.Set<E> expectedSet)
           
static
<T> void
GeneratorTest.checkProductSet(Generator<T> generator, int iterations, java.util.Set<T> expectedSet)
           
 void GeneratorTest.close(Generator<?> generator)
           
static
<T> java.util.Map<T,java.util.concurrent.atomic.AtomicInteger>
GeneratorTest.countProducts(Generator<T> generator, int n)
           
protected static
<T> GeneratorTest.Helper
GeneratorTest.expectGeneratedSequence(Generator<T> generator, T... products)
           
protected static
<T> void
GeneratorTest.expectGeneratedSequenceOnce(Generator<T> generator, T... products)
           
protected
<T> GeneratorTest.Helper
GeneratorTest.expectGeneratedSet(Generator<T> generator, int invocations, T... products)
           
protected
<T> GeneratorTest.Helper
GeneratorTest.expectGenerations(Generator<T> generator, int n, org.databene.commons.Validator... validators)
           
protected
<T extends java.lang.Comparable<T>>
GeneratorTest.Helper
GeneratorTest.expectRange(Generator<T> generator, int n, T min, T max)
           
protected
<T extends java.lang.Comparable<T>>
void
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
<T> GeneratorTest.Helper
GeneratorTest.expectUniqueGenerations(Generator<T> generator, int n)
           
protected
<T> GeneratorTest.Helper
GeneratorTest.expectUniquelyGeneratedSet(Generator<T> generator, T... products)
           
protected
<T> GeneratorTest.Helper
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 Generators 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
<T> java.util.List<T>
GeneratorUtil.allProducts(Generator<T> generator)
           
static void GeneratorUtil.close(Generator<?> generator)
           
static
<T> java.lang.Class<T>
GeneratorUtil.commonTargetTypeOf(Generator<T>... sources)
           
protected  E GeneratorIterator.fetchNext(Generator<E> source)
           
static
<T> T
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
<T> T
GeneratorUtil.generateNullable(Generator<T> generator)
          Calls a Generator's generate(ProductWrapper) method and returns its unwrapped result, allowing null values as generation results, but requiring the generator to be available.
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 Strings.
 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 ProductWrappers 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 Generators 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 NonNullGenerators.
 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
<T extends Generator<U>,U>
T
CompositeGenerator.registerComponent(T component)
           
 

Methods in org.databene.benerator.wrapper that return Generator
static
<S,T> Generator<T>
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
<T> Generator<T>
WrapperFactory.applyCycler(Generator<T> generator)
           
static
<T> Generator<T>
WrapperFactory.applyHeadCycler(Generator<T> source)
           
static
<T> Generator<T>
WrapperFactory.applyLastProductDetector(Generator<T> generator)
           
static
<T> Generator<T>
WrapperFactory.applyValidator(org.databene.commons.Validator<T> validator, Generator<T> generator)
           
static
<T extends java.lang.Number>
Generator<T>
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
<T> Generator<T>
WrapperFactory.injectNulls(Generator<T> source, double nullQuota)
           
static
<T> Generator<T>
WrapperFactory.prependNull(Generator<T> source)
           
static
<T> Generator<T>
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
<S,T> Generator<T>
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
<T> Generator<T>
WrapperFactory.applyCycler(Generator<T> generator)
           
static
<T> Generator<T>
WrapperFactory.applyHeadCycler(Generator<T> source)
           
static
<T> Generator<T>
WrapperFactory.applyLastProductDetector(Generator<T> generator)
           
static
<T> OffsetBasedGenerator<T>
WrapperFactory.applyOffset(Generator<T> generator, int offset)
           
static
<T> Generator<T>
WrapperFactory.applyValidator(org.databene.commons.Validator<T> validator, Generator<T> generator)
           
static
<T> NonNullGenerator<T>
WrapperFactory.asNonNullGenerator(Generator<T> source)
           
static
<T extends java.lang.Number>
Generator<T>
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
<T> org.databene.commons.Converter<T,java.lang.String>
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
<T> Generator<T>
WrapperFactory.injectNulls(Generator<T> source, double nullQuota)
           
static
<T> Generator<T>
WrapperFactory.prependNull(Generator<T> source)
           
static
<T> Generator<T>
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 BankAccounts with low validity requirements.
 class BankGenerator
          Generates BankAccounts 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 Nouns 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
<T extends Generator<U>,U>
T
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 Generators.
 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.
 



Copyright © 2013. All Rights Reserved.