Creates a field transformer that patches the transformed field by the given modifier contributors.

@param modifierContributor The modifier contributors to apply.
@return A suitable field transformer.
325049
public static Transformer<FieldDescription> withModifiers(ModifierContributor.ForField... modifierContributor) {
            return withModifiers(Arrays.asList(modifierContributor));
        }
717807
public static <A, B, C> FeatureGenerator<A, C> postConvertingFeatureGenerator(
      FeatureGenerator<A, B> generator, Function<B, C> converter) {
    return new PostConvertingFeatureGenerator<A, B, C>(generator, converter);
  }
1324146
public void concatField(String targetField, String concatString, String... sourceFields) {
        TransformationStep step = new TransformationStep();
        step.setTargetField(targetField);
        step.setSourceFields(sourceFields);
        step.setOperationParameter(TransformationConstants.CONCAT_PARAM, concatString);
        step.setOperationName("concat");
        steps.add(step);
    }
767151
public AnnotatedTypeBuilder<X> addToField(Field field, Annotation annotation) {
       if (fields.get(field) == null) {
           fields.put(field, new AnnotationBuilder());
       }
       fields.get(field).add(annotation);
       return this;
   }
305374
public AbstractBuilder getFieldBuilder(ClassWriter classWriter)
            throws Exception {
        return FieldBuilder.getInstance(context, classWriter.getClassDoc(),
            writerFactory.getFieldWriter(classWriter));
    }
221589
public JodaBeanSer withConverter(StringConvert converter) {
        JodaBeanUtils.notNull(converter, "converter");
        return new JodaBeanSer(indent, newLine, converter, iteratorFactory, shortTypes, deserializers, includeDerived);
    }
456162
public <R> ValueTransformer<W,R> mergeMap(Function<? super T, ? extends Publisher<? extends R>> mapper) {
        return unitAnyM(this.transformerStream().map(v->v.mergeMap(mapper)));
    }
411570
private static <T, G extends T> void generateConstructorAndFields(DexMaker dexMaker,
                                                                      TypeId<G> generatedType,
                                                                      TypeId<T> baseType) {
        final FieldId<G, Interceptor> interceptorField =
                generatedType.getField(INTERCEPTOR_TYPE, FIELD_NAME_INTERCEPTOR);
        dexMaker.declare(interceptorField, PRIVATE, null);

        final TypeId<?>[] types = classArrayToTypeArray(CONSTRUCTOR_ARG_TYPES);
        final MethodId<?, ?> constructor = generatedType.getConstructor(types);
        final Code constructorCode = dexMaker.declare(constructor, PUBLIC);

        final Local<?>[] params = new Local[types.length];
        for (int i = 0; i < params.length; ++i) {
            params[i] = constructorCode.getParameter(i, types[i]);
        }

        final MethodId<T, ?> superConstructor = baseType.getConstructor(types);
        final Local<G> thisRef = constructorCode.getThis(generatedType);
        constructorCode.invokeDirect(superConstructor, null, thisRef, params);
        constructorCode.returnVoid();
    }
130404
protected TransformerBuilder createTransformerBuilder(URIResolver resolver) {
		//return new CachingTransformerBuilder(new DefaultTransformerBuilder(resolver));
		URIResolver resolver1 = new GlossaryResolver(new DocBookResolver (resolver, getType()), getType());
		return new CachingTransformerBuilder(new DefaultTransformerBuilder(resolver1));
	}
237585
private void addPojoField(final TypeSpec.Builder classBuilder,
                              final MethodSpec.Builder constructorBuilder,
                              final String fieldName,
                              final TypeName fieldClass) {
        classBuilder.addField(fieldClass, fieldName, Modifier.PRIVATE, Modifier.FINAL);
        addGetter(classBuilder, fieldName, fieldClass);
        addConstructorParameter(constructorBuilder, fieldName, fieldClass);
    }
298214
@SuppressWarnings("unchecked")
    public <TO> ChainedTransformer<I, TO> chain(Transformer<O, TO> transformer) {
        if (transformer != null) {
            transformers.add(transformer);
        }
        return (ChainedTransformer<I, TO>) this;
    }
399626
public static Constraint modificationConstraint(String modifTerm)
	{
		return new FieldOfMultiple(new MappedConst(new LinkedPE(LinkedPE.Type.TO_SPECIFIC), 0),
			"PhysicalEntity/feature:ModificationFeature/modificationType/term",
			Field.Operation.INTERSECT, modifTerm);
	}
882023
public static <T extends Transformer<?>> TransformerBeanDescriptor<T> ofTransformer(Class<T> transformerClass) {
        return new AnnotationBasedTransformerBeanDescriptor<T>(transformerClass);
    }
56946
public void addModifier(String modifier) {
		if (!Strings.isEmpty(modifier)) {
			getSarlAction().getModifiers().add(modifier);
		}
	}
692052
public static <D extends DifferenceEngineConfigurer<D>>
        D withPlaceholderSupport(D configurer) {
        return withPlaceholderSupportUsingDelimiters(configurer, null, null);
    }
1273225
protected Converter createConverter(FaceletContext ctx)
    {
        if (_delegate.getConverterId(ctx) == null)
        {
            throw new TagException(_delegate.getTag(),
                                    "Default behavior invoked of requiring a converter-id passed in the "
                                    + "constructor, must override ConvertHandler(ConverterConfig)");
        }
        return ctx.getFacesContext().getApplication().createConverter(_delegate.getConverterId(ctx));
    }
443786
public static boolean hasModifier(Field field, ModifierType... modifierTypes) {
		if (null == field || ArrayUtil.isEmpty(modifierTypes)) {
			return false;
		}
		return 0 != (field.getModifiers() & modifiersToInt(modifierTypes));
	}