Uses of Class
org.databene.benerator.util.AbstractGenerator

Packages that use AbstractGenerator
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.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.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 AbstractGenerator in org.databene.benerator.composite
 

Subclasses of AbstractGenerator in org.databene.benerator.composite
 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.
 

Uses of AbstractGenerator in org.databene.benerator.csv
 

Subclasses of AbstractGenerator in org.databene.benerator.csv
 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 AbstractGenerator in org.databene.benerator.dataset
 

Subclasses of AbstractGenerator in org.databene.benerator.dataset
 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.
 

Uses of AbstractGenerator in org.databene.benerator.distribution
 

Subclasses of AbstractGenerator in org.databene.benerator.distribution
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.
 

Uses of AbstractGenerator in org.databene.benerator.distribution.sequence
 

Subclasses of AbstractGenerator in org.databene.benerator.distribution.sequence
 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.
 

Uses of AbstractGenerator in org.databene.benerator.engine
 

Subclasses of AbstractGenerator in org.databene.benerator.engine
 class DescriptorBasedGenerator
          Provides easy programmatic access to generators defined in an XML descriptor file.
 

Uses of AbstractGenerator in org.databene.benerator.file
 

Subclasses of AbstractGenerator in org.databene.benerator.file
 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.
 

Uses of AbstractGenerator in org.databene.benerator.primitive
 

Subclasses of AbstractGenerator in org.databene.benerator.primitive
 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 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().
 

Uses of AbstractGenerator in org.databene.benerator.primitive.datetime
 

Subclasses of AbstractGenerator in org.databene.benerator.primitive.datetime
 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 AbstractGenerator in org.databene.benerator.primitive.number
 

Subclasses of AbstractGenerator in org.databene.benerator.primitive.number
 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 AbstractGenerator in org.databene.benerator.sample
 

Subclasses of AbstractGenerator in org.databene.benerator.sample
 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 AbstractGenerator in org.databene.benerator.util
 

Subclasses of AbstractGenerator in org.databene.benerator.util
 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.
 

Uses of AbstractGenerator in org.databene.benerator.wrapper
 

Subclasses of AbstractGenerator in org.databene.benerator.wrapper
 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 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.
 

Uses of AbstractGenerator in org.databene.domain.address
 

Subclasses of AbstractGenerator in org.databene.domain.address
 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 AbstractGenerator in org.databene.domain.br
 

Subclasses of AbstractGenerator in org.databene.domain.br
 class CNPJGenerator
          Generates Brazilian CNPJ numbers.
 class CPFGenerator
          Generates Brazilian CPF numbers.
 

Uses of AbstractGenerator in org.databene.domain.finance
 

Subclasses of AbstractGenerator in org.databene.domain.finance
 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 AbstractGenerator in org.databene.domain.lang
 

Subclasses of AbstractGenerator in org.databene.domain.lang
 class NounGenerator
          Generates Nouns of a given Locale.
 

Uses of AbstractGenerator in org.databene.domain.math
 

Subclasses of AbstractGenerator in org.databene.domain.math
 class FibonacciLongGenerator
          Generates Fibonacci Numbers.
 class PadovanLongGenerator
          Generates numbers according to the Padovan Sequence.
 

Uses of AbstractGenerator in org.databene.domain.net
 

Subclasses of AbstractGenerator in org.databene.domain.net
 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 AbstractGenerator in org.databene.domain.organization
 

Subclasses of AbstractGenerator in org.databene.domain.organization
 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.
 

Uses of AbstractGenerator in org.databene.domain.person
 

Subclasses of AbstractGenerator in org.databene.domain.person
 class AcademicTitleGenerator
          Creates a quota of academic titles.
 class BirthDateGenerator
          Creates Date objects for a person's birth day.
 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').
 

Uses of AbstractGenerator in org.databene.domain.product
 

Subclasses of AbstractGenerator in org.databene.domain.product
 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 AbstractGenerator in org.databene.domain.us
 

Subclasses of AbstractGenerator in org.databene.domain.us
 class SSNGenerator
          Generates US Social Security Numbers.
 

Uses of AbstractGenerator in org.databene.platform.db
 

Subclasses of AbstractGenerator in org.databene.platform.db
 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.