<p>getTransformer.</p>

@param transformerClass a {@link java.lang.Class} object.
@param <R>              Result.
@param <T>              Transformer.
@return a {@link java.lang.Iterable} object.
488978
protected <R, T extends Transformer<Transformed<R>>> Iterable<T> getTransformer(Class<T> transformerClass) {
        return Providers.getAllRankedSortedProviders(manager, transformerClass);
    }
1354932
@Override
    protected T transformElement(Map<String, Object> entity) {
        try {
            return (T)UtilJdbc.getObjectFromRow(jdbcDeepJobConfig.getEntityClass(), entity, jdbcDeepJobConfig);
        } catch(IllegalAccessException | InvocationTargetException | InstantiationException e) {
            throw new DeepTransformException(e);
        }
    }
691445
@Override
    public final Transformer getTransformer(
            HttpServletRequest request, HttpServletResponse response) {
        final Resource stylesheetResource = this.getStylesheetResource(request);
        try {
            return this.xmlUtilities.getTransformer(stylesheetResource);
        } catch (TransformerConfigurationException e) {
            throw new RuntimeException(
                    "Failed to get Transformer for stylesheet: " + stylesheetResource, e);
        } catch (IOException e) {
            throw new RuntimeException("Failed to load stylesheet: " + stylesheetResource, e);
        }
    }
634125
@SuppressWarnings("unchecked")
  public <T extends R> Converter<S, T> getConverter(Class<T> targetType) {
    return (Converter<S, T>) converters.get(targetType);
  }
166349
public static <T> Transformed<T> succ(Transformer transformer, T result) {
        return new Basic<>(transformer, result, true);
    }
886442
protected function getTransformer()
    {
        $transformer = null;

        // Check if controller specifies a resource
        if (! is_null(static::$transformer)) {
            $transformer = static::$transformer;
        }

        // Otherwise, check if model is specified
        else {
            // If it is, check if the controller's model specifies the transformer
            if (! is_null(static::$model)) {
                // If it does, use it
                if (! is_null((static::$model)::$transformer)) {
                    $transformer = (static::$model)::$transformer;
                }
            }
        }

        // This is the default transformer, if one is not specified
        if (is_null($transformer)) {
            $transformer = BaseTransformer::class;
        }

        return new $transformer;
    }
712955
protected Transformer _newTransformer()
    {
        Transformer  transformer = null;

        if (_stylesheet == null) {
            try {
                transformer = TransformerFactory.newInstance().newTransformer();
            } catch (Exception ex) {
                throw new XmlException( ex );
            }

            return transformer;
        }

        if (_templates == null) {
            _templates = _getTemplates( _stylesheet );
        }

        try {
            transformer = _templates.newTransformer();
                                     //throws TransformerConfigurationException

            if (_params.size() > 0) {
                for (String  name : _params.keySet()) {
                    Object  value = _params.get( name );
                    transformer.setParameter( name, value );
                }
            }
        } catch (Exception ex) {
            throw new XmlException( ex );
        }

        return transformer;
    }
889227
private List<StubTransformer> getStubTransformers() {
        if (this.stubTransformers == null) {
            final Collection<StubTransformer> transformers =
                    this.applicationContext.getBeansOfType(StubTransformer.class).values();
            this.stubTransformers = new ArrayList<>(transformers);
            return this.stubTransformers;
        }
        return this.stubTransformers;
    }
497007
public static XslTransformer getTransformer(File xslFile) throws TransformerConfigurationException {
    	if (xslFile == null) {
    		throw new IllegalArgumentException("xslFile is null");
    	}
        return getTransformer(new StreamSource(xslFile));
    }
888082
public void execute(
          TransformerImpl transformer)
            throws TransformerException
  {

    int sourceNode = transformer.getXPathContext().getCurrentNode();
    String countString = getCountString(transformer, sourceNode);

    try
    {
      transformer.getResultTreeHandler().characters(countString.toCharArray(),
                                                    0, countString.length());
    }
    catch(SAXException se)
    {
      throw new TransformerException(se);
    }
  }
1033294
private void initializeTransformer() {
    TransformerFactory transformerFactory = new TransformerFactory();
    transformer = transformerFactory.getTransformer(topViewResize, dragView, this);
    transformer.setViewHeight(topViewHeight);
    transformer.setXScaleFactor(scaleFactorX);
    transformer.setYScaleFactor(scaleFactorY);
    transformer.setMarginRight(marginRight);
    transformer.setMarginBottom(marginBottom);
  }
1359557
@Override
    public final void addTransformer(ClassTransformer transformerClass) {
        final boolean isTraceOn = TraceComponent.isAnyTracingEnabled();
        if (isTraceOn && tc.isEntryEnabled()) {
            Tr.entry(tc, "addTransformer: PUID = " + ivArchivePuId + ", transformer = " + transformerClass); //d454146
        }

        if (transformerClass != null) {
            JPAComponent jpaComp = getJPAComponent();
            if (jpaComp != null && jpaComp.getCaptureEnhancedEntityClassBytecode()) {
                transformerClass = new CapturingClassTransformer(transformerClass, ivApplInfo.getApplName(), jpaComp.getServerLogDirectory());
            }
        }

        ivTransformers.add(transformerClass);

        if (isTraceOn && tc.isEntryEnabled()) {
            Tr.exit(tc, "addTransformer : # registered transfromer = " + ivTransformers.size());
        }
    }
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));
    }
362076
public static <P, R> List<R> transform(List<P> elements, Function<P, R> transformer) {
        return Lists.transform(elements, transformer);
    }
911422
public static <T> Observable.Transformer<T,ImmutableSet<T>> toImmutableSet() {
        return new Observable.Transformer<T, ImmutableSet<T>>() {
            @Override
            public Observable<ImmutableSet<T>> call(Observable<T> source) {
                return source.collect(new Func0<ImmutableSet.Builder<T>>() {
                    @Override
                    public ImmutableSet.Builder<T> call() {
                        return ImmutableSet.builder();
                    }
                }, new Action2<ImmutableSet.Builder<T>, T>() {
                    @Override
                    public void call(ImmutableSet.Builder<T> builder, T t) {
                        builder.add(t);
                    }
                })
                .map(new Func1<ImmutableSet.Builder<T>, ImmutableSet<T>>() {
                    @Override
                    public ImmutableSet<T> call(ImmutableSet.Builder<T> builder) {
                        return builder.build();
                    }
                });
            }
        };
    }
144273
public function setTransformer($transformer)
    {
        if ($transformer !== null) {
            if (!$this->isValidTransformer($transformer)) {
                throw new InvalidTransformerException('Transformer must be a callable or implement TransformerInterface');
            }
        }

        $this->transformer = $transformer;

        return $this;
    }
298214
@SuppressWarnings("unchecked")
    public <TO> ChainedTransformer<I, TO> chain(Transformer<O, TO> transformer) {
        if (transformer != null) {
            transformers.add(transformer);
        }
        return (ChainedTransformer<I, TO>) this;
    }