Returns a fetch of transformers applicable to the given constructor.

@param constructor constructor
@return transformers
339991
public static Iterable<Function<Object[], Object[]>> getTransformers(Constructor<?> constructor) {
        Iterable<ArgumentTransformer> transformers = Lists.newArrayList(
                new PrimitiveAwareVarArgsTransformer(constructor),
                new PrimitiveTransformer(constructor),
                new VarArgsTransformer(constructor));

        return ImmutableList
                .<Function<Object[], Object[]>>copyOf(filter(transformers, applicableFilter));
    }
1320634
public static <X> IteratorFromReaderFactory<X> getFactory(Function<String,X> op) {
    return new LineIteratorFactory<X>(op);
  }
973568
static TransformerFactory newTransformerFactory() {
        TransformerFactory tf = TransformerFactory.newInstance();
        if (uriResolver != null) {
            tf.setURIResolver(uriResolver);
        }
        if (enableXXEProtection) {
            tf = TransformerFactoryConfigurer.Default.configure(tf);
        }
        return tf;
    }
1280866
public static String getConstructorDesc(Constructor<?> constructor) {
        Assert.notNull(constructor);
        return getDesc(void.class, constructor.getParameterTypes());
    }
384595
public static TransformerFactory newTransformerFactory( String factoryClassName, ClassLoader classLoader )
        throws NoSuchMethodException, IllegalAccessException, InvocationTargetException
    {
        // use reflection to avoid JAXP 1.4 (and hence JDK6) requirement

        Class<?>[] methodTypes = new Class[] { String.class, ClassLoader.class };

        Method method = TransformerFactory.class.getDeclaredMethod( "newInstance", methodTypes );

        Object[] methodArgs = new Object[] { factoryClassName, classLoader };

        return (TransformerFactory) method.invoke( null, methodArgs );
    }
894714
private TransformerFactory getTransformerFactory()
        throws MojoFailureException, MojoExecutionException
    {
        if ( transformerFactory == null )
        {
            return TransformerFactory.newInstance();
        }

        try
        {
            return newTransformerFactory( transformerFactory, Thread.currentThread().getContextClassLoader() );
        }
        catch ( NoSuchMethodException exception )
        {
            throw new MojoFailureException( "JDK6 required when using transformerFactory parameter" );
        }
        catch ( IllegalAccessException exception )
        {
            throw new MojoExecutionException( "Cannot instantiate transformer factory", exception );
        }
        catch ( InvocationTargetException exception )
        {
            throw new MojoExecutionException( "Cannot instantiate transformer factory", exception );
        }
    }
523993
public Set<Constructor> getConstructorsAnnotatedWith(final Class<? extends Annotation> annotation) {
        Iterable<String> methods = store.get(index(MethodAnnotationsScanner.class), annotation.getName());
        return getConstructorsFromDescriptors(methods, loaders());
    }
725767
public Constructor[] getConstructors(Class clazz, int count) {
	Array con;
	Object o;
	synchronized (map) {
	    o = map.get(clazz);
	    if (o == null) {
		con = store(clazz);
	    }
	    else con = (Array) o;
	}
	o = con.get(count + 1, null);
	if (o == null) return null;
	return (Constructor[]) o;
    }
169248
public static Transformer<FieldDescription> withModifiers(List<? extends ModifierContributor.ForField> modifierContributors) {
            return new ForField(new FieldModifierTransformer(ModifierContributor.Resolver.of(modifierContributors)));
        }
362076
public static <P, R> List<R> transform(List<P> elements, Function<P, R> transformer) {
        return Lists.transform(elements, transformer);
    }
1039890
public static List<String> getList(Iterator<String> iterator) {
        List<String> contents = new ArrayList<String>();
        while (iterator.hasNext()) {
            contents.add(iterator.next());
        }
        return contents;
    }
232026
private ReferenceFactory<?> createFactory(final Constructor<?> constructor) {
    return manager -> {
      try {
        return (ReferenceCounted<?>) constructor.newInstance(manager);
      } catch (InstantiationException | IllegalAccessException | InvocationTargetException e) {
        throw new SerializationException("failed to instantiate reference", e);
      }
    };
  }
711803
public static <T> List<Settable> getConstructorParameters(Constructor<T> constructor, Class<?> ownerType) {
        Type[] parameterTypes = constructor.getGenericParameterTypes();
        Annotation[][] parameterAnnotations = constructor.getParameterAnnotations();
        List<Settable> params = Lists.newArrayList();
        for (int i = 0; i < parameterTypes.length; i++) {
            Parameter parameterWrap = new Parameter(parameterTypes[i], i, parameterAnnotations[i]);
            Settable settable = SettableParameter.from(ownerType, parameterWrap);
            params.add(settable);
        }
        return params;
    }
1342908
protected Transformer findTransformer(Class<?> clazz) {
        Transformer answer = transformers.get(clazz);
        if(answer == null)
            throw new IllegalArgumentException("Can not transform value of " + clazz);
        return answer;
    }
514662
public List<ConstructorResult<SqlResultSetMapping<T>>> getAllConstructorResult()
   {
      List<ConstructorResult<SqlResultSetMapping<T>>> list = new ArrayList<ConstructorResult<SqlResultSetMapping<T>>>();
      List<Node> nodeList = childNode.get("constructor-result");
      for(Node node: nodeList)
      {
         ConstructorResult<SqlResultSetMapping<T>>  type = new ConstructorResultImpl<SqlResultSetMapping<T>>(this, "constructor-result", childNode, node);
         list.add(type);
      }
      return list;
   }
1356023
public static Enum<?>[][] explodeArguments(TestConstructor constructor) {
    checkNotNull(constructor, "constructor");

    return explodeParameters(constructor.getVariationTypes(),
        constructor.getName() + " constructor");
  }
623976
function getTransformer(name) {
    if (name in transformers) {
      return transformers[name]
    }
    const transformer = toTransformer(name)
    transformers[name] = transformer ? jstransformer(transformer) : false
    return transformers[name]
  }