private static ComponentBuilder<?> builderFromGenerator(
     Generator<?> source, ComponentDescriptor descriptor, BeneratorContext context) {
   boolean nullability = DescriptorUtil.isNullable(descriptor, context);
   Double nullQuota = descriptor.getNullQuota();
   if (nullQuota != null && nullQuota != 0)
     source = context.getGeneratorFactory().applyNullSettings(source, nullability, nullQuota);
   TypeDescriptor typeDescriptor = descriptor.getTypeDescriptor();
   String scope = (typeDescriptor != null ? typeDescriptor.getScope() : null);
   if (descriptor instanceof ArrayElementDescriptor) {
     int index = ((ArrayElementDescriptor) descriptor).getIndex();
     return new ArrayElementBuilder(index, source, scope);
   } else return new PlainEntityComponentBuilder(descriptor.getName(), source, scope);
 }
 public boolean apply(E target, BeneratorContext context) {
   BeneratorContext subContext = context.createSubContext(instanceName);
   subContext.setCurrentProduct(new ProductWrapper<E>(target));
   for (GeneratorComponent<E> component : components) {
     try {
       if (!component.execute(subContext)) {
         message =
             "Component generator for '"
                 + instanceName
                 + "' is not available any longer: "
                 + component;
         STATE_LOGGER.debug(message);
         return false;
       }
     } catch (Exception e) {
       throw new RuntimeException(
           "Failure in generation of '" + instanceName + "', " + "Failed component: " + component,
           e);
     }
   }
   LOGGER.debug("Generated {}", target);
   subContext.close();
   return true;
 }
 @Override
 protected Generator<Object[]> createSourceGenerator(
     ArrayTypeDescriptor descriptor, Uniqueness uniqueness, BeneratorContext context) {
   // if no sourceObject is specified, there's nothing to do
   String sourceName = descriptor.getSource();
   if (sourceName == null) return null;
   // create sourceObject generator
   Generator<Object[]> generator = null;
   Object contextSourceObject = context.get(sourceName);
   if (contextSourceObject != null)
     generator =
         createSourceGeneratorFromObject(descriptor, context, generator, contextSourceObject);
   else {
     String lcSourceName = sourceName.toLowerCase();
     if (lcSourceName.endsWith(".csv"))
       generator = createCSVSourceGenerator(descriptor, context, sourceName);
     else if (lcSourceName.endsWith(".xls"))
       generator = createXLSSourceGenerator(descriptor, context, sourceName);
     else {
       try {
         BeanSpec sourceBeanSpec = DatabeneScriptParser.resolveBeanSpec(sourceName, context);
         Object sourceObject = sourceBeanSpec.getBean();
         if (!sourceBeanSpec.isReference() && sourceObject instanceof ContextAware)
           ((ContextAware) sourceObject).setContext(context);
         generator = createSourceGeneratorFromObject(descriptor, context, generator, sourceObject);
         if (sourceBeanSpec.isReference()) generator = WrapperFactory.preventClosing(generator);
         return generator;
       } catch (Exception e) {
         throw new UnsupportedOperationException("Unknown source type: " + sourceName);
       }
     }
   }
   if (descriptor.getFilter() != null) {
     Expression<Boolean> filter =
         new ScriptExpression<Boolean>(ScriptUtil.parseScriptText(descriptor.getFilter()));
     generator = new FilteringGenerator<Object[]>(generator, filter);
   }
   Distribution distribution =
       FactoryUtil.getDistribution(descriptor.getDistribution(), uniqueness, false, context);
   if (distribution != null)
     generator =
         new DistributingGenerator<Object[]>(generator, distribution, uniqueness.isUnique());
   return generator;
 }
 @SuppressWarnings({"rawtypes", "unchecked"})
 @Override
 protected Generator<?> applyComponentBuilders(
     Generator<?> generator,
     ArrayTypeDescriptor descriptor,
     String instanceName,
     Uniqueness uniqueness,
     BeneratorContext context) {
   Generator[] generators;
   // create synthetic element generators if necessary
   if (generator instanceof BlankArrayGenerator) {
     generators = createSyntheticElementGenerators(descriptor, uniqueness, context);
     generator =
         context
             .getGeneratorFactory()
             .createCompositeArrayGenerator(Object.class, generators, uniqueness);
   }
   // ... and don't forget to support the parent class' functionality
   generator =
       super.applyComponentBuilders(generator, descriptor, instanceName, uniqueness, context);
   return generator;
 }
 private Generator<Object[]> createCSVSourceGenerator(
     ArrayTypeDescriptor arrayType, BeneratorContext context, String sourceName) {
   logger.debug("createCSVSourceGenerator({})", arrayType);
   String encoding = arrayType.getEncoding();
   if (encoding == null) encoding = context.getDefaultEncoding();
   char separator = DescriptorUtil.getSeparator(arrayType, context);
   boolean rowBased = (arrayType.isRowBased() != null ? arrayType.isRowBased() : true);
   DataSourceProvider<Object[]> factory =
       new CSVArraySourceProvider(
           arrayType.getName(),
           new ScriptConverterForStrings(context),
           rowBased,
           separator,
           encoding);
   Generator<Object[]> generator =
       SourceFactory.createRawSourceGenerator(
           arrayType.getNesting(),
           arrayType.getDataset(),
           sourceName,
           factory,
           Object[].class,
           context);
   return WrapperFactory.applyConverter(generator, new ArrayElementTypeConverter(arrayType));
 }
  @SuppressWarnings({"unchecked", "rawtypes"})
  static ComponentBuilder<?> createReferenceBuilder(
      ReferenceDescriptor descriptor, BeneratorContext context) {
    SimpleTypeDescriptor typeDescriptor = (SimpleTypeDescriptor) descriptor.getTypeDescriptor();

    // check uniqueness
    boolean unique = DescriptorUtil.isUnique(descriptor, context);
    Uniqueness uniqueness = (unique ? Uniqueness.SIMPLE : Uniqueness.NONE);

    // do I only need to generate nulls?
    if (DescriptorUtil.isNullable(descriptor, context)
        && DescriptorUtil.shouldNullifyEachNullable(descriptor, context))
      return builderFromGenerator(createNullGenerator(descriptor, context), descriptor, context);

    // TODO use SimpleTypeGeneratorFactory?
    Generator<?> generator = null;
    generator = DescriptorUtil.getGeneratorByName(typeDescriptor, context);
    if (generator == null)
      generator = SimpleTypeGeneratorFactory.createScriptGenerator(typeDescriptor);
    if (generator == null)
      generator = SimpleTypeGeneratorFactory.createConstantGenerator(typeDescriptor, context);
    if (generator == null)
      generator =
          SimpleTypeGeneratorFactory.createValuesGenerator(typeDescriptor, uniqueness, context);

    // get distribution
    Distribution distribution =
        FactoryUtil.getDistribution(
            typeDescriptor.getDistribution(), descriptor.getUniqueness(), false, context);

    // check source
    if (generator == null) {
      // check target type
      String targetTypeName = descriptor.getTargetType();
      ComplexTypeDescriptor targetType =
          (ComplexTypeDescriptor) context.getDataModel().getTypeDescriptor(targetTypeName);
      if (targetType == null) throw new ConfigurationError("Type not defined: " + targetTypeName);

      // check targetComponent
      String targetComponent = descriptor.getTargetComponent();

      // check source
      String sourceName = typeDescriptor.getSource();
      if (sourceName == null) throw new ConfigurationError("'source' is not set for " + descriptor);
      Object sourceObject = context.get(sourceName);
      if (sourceObject instanceof StorageSystem) {
        StorageSystem sourceSystem = (StorageSystem) sourceObject;
        String selector = typeDescriptor.getSelector();
        String subSelector = typeDescriptor.getSubSelector();
        boolean subSelect = !StringUtil.isEmpty(subSelector);
        String selectorToUse = (subSelect ? subSelector : selector);
        if (isIndividualSelector(selectorToUse)) {
          generator = new DataSourceGenerator(sourceSystem.query(selectorToUse, true, context));
        } else {
          generator =
              new DataSourceGenerator(
                  sourceSystem.queryEntityIds(
                      targetTypeName,
                      selectorToUse,
                      context)); // TODO v0.7.2 query by targetComponent
          if (selectorToUse == null && distribution == null)
            if (context.isDefaultOneToOne()) distribution = new ExpandSequence();
            else distribution = SequenceManager.RANDOM_SEQUENCE;
        }
        if (subSelect) generator = WrapperFactory.applyHeadCycler(generator);
      } else throw new ConfigurationError("Not a supported source type: " + sourceName);
    }

    // apply distribution if necessary
    if (distribution != null)
      generator = new DistributingGenerator(generator, distribution, unique);

    // check multiplicity
    generator = ComponentBuilderFactory.createMultiplicityWrapper(descriptor, generator, context);
    if (LOGGER.isDebugEnabled()) LOGGER.debug("Created " + generator);

    // check 'cyclic' config
    generator = DescriptorUtil.wrapWithProxy(generator, typeDescriptor);
    return builderFromGenerator(generator, descriptor, context);
  }