Get a list of all transformers.
@return Transformer[]
@throws \CatLab\Charon\Exceptions\InvalidTransformer
183958
protected function getTransformers()
    {
        $out = [];

        foreach ($this->transformers as $transformer) {
            if ($transformer instanceof Transformer) {
                $out[] = $transformer;
            } else if (is_string($transformer)) {
                $out[] = TransformerLibrary::make($transformer);
            } else {
                throw new LogicException("All transformers must implement " . Transformer::class);
            }
        }

        return $out;
    }
226079
public function toArray()
	{
		$this->data = $this->transformer->transformBack($this->data);

		return $this->data;
	}
1074862
public function transform()
    {
        $data = $this->getData();

        $transformedData = [
            'identifier' => ((isset($data['id']) === true) ? $data['id'] : ''),
            'name' => $data['_name'],
            'description' => ((isset($data['description']) === true) ? $data['description'] : ''),
            'kind' => ((isset($data['kind']) === true) ? $data['kind'] : ''),
            'state' => ((isset($data['state']) === true) ? $data['state'] : ''),
            'parent' => ((isset($data['parent']) === true) ? $data['parent'] : '')
        ];

        return $transformedData;
    }
46582
public function getIncludes(): array
    {
        if ($this->includes === null) {
            $this->includes = TransformerHelper::normalizeIncludes(
                $this->defineIncludes()
            );
        }

        return $this->includes;
    }
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;
    }
914515
public function getFlattenValidators()
    {
        if (!$this->exists) {
            return [];
        }

        $validators = $this->validators;
        $return     = [];
        if (!empty($validators)) {
            foreach ($validators as $validator) {
                $return[$validator->validator_id] = $validator->value;
            }
        }
        return $return;
    }
1113757
public function executeOn(Collection $collection)
    {
        if (empty($collection) || $collection->first() === null) {
            return $collection;
        }

        $transformer = $this->repository->transformer;

        if (!(new \ReflectionClass($transformer))->implementsInterface(TransformerInterface::class)) {
            throw new InvalidTransformer();
        }

        /** @var TransformerInterface $transformer */
        $transformer = new $transformer($collection);

        return $transformer->execute();
    }
566726
public function getCrossingChars(): array
    {
        return [
            $this->crossingChar,
            $this->crossingTopLeftChar,
            $this->crossingTopMidChar,
            $this->crossingTopRightChar,
            $this->crossingMidRightChar,
            $this->crossingBottomRightChar,
            $this->crossingBottomMidChar,
            $this->crossingBottomLeftChar,
            $this->crossingMidLeftChar,
            $this->crossingTopLeftBottomChar,
            $this->crossingTopMidBottomChar,
            $this->crossingTopRightBottomChar,
        ];
    }
1205575
public function getMutators(): array
    {
        $mutators = [
            self::MUTATOR_GETTER   => [],
            self::MUTATOR_SETTER   => [],
            self::MUTATOR_ACCESSOR => [],
        ];

        foreach ((array)$this->getProperty('getters', true) as $field => $filter) {
            $mutators[self::MUTATOR_GETTER][$field] = $filter;
        }

        foreach ((array)$this->getProperty('setters', true) as $field => $filter) {
            $mutators[self::MUTATOR_SETTER][$field] = $filter;
        }

        foreach ((array)$this->getProperty('accessors', true) as $field => $filter) {
            $mutators[self::MUTATOR_ACCESSOR][$field] = $filter;
        }

        return $mutators;
    }
1075544
protected function transform($transformable)
    {
        if ($transformable instanceof Collection) {
            return $this->transformCollection($transformable);
        }

        if ($transformable instanceof TransformableContract) {
            return $this->transformTransformable($transformable);
        }

        if ($transformable instanceof DirectTransformableContract) {
            return $transformable->directTransform();
        }

        return $transformable;
    }
133053
protected function getTransformer()
    {
        if (is_callable($this->transformer) || $this->transformer instanceof TransformerAbstract) {
            return $this->transformer;
        }

        return Craft::createObject($this->transformer);
    }
362312
public Transformer[] getDataProviderOutputTransformers() {
        Transformer[] transformers;

        if (dataProviderOutputTransformers == null) {
            transformers = null;
        } else {
            transformers = dataProviderOutputTransformers.toArray(new Transformer[dataProviderOutputTransformers.size
                    ()]);
        }

        return transformers;
    }
1294328
public function transformEntity($entity, $transformer = null, SerializerAbstract $serializer = null): array
	{
		$transformer = $transformer ?: $this->getTransformerFromClassProperty();

		$results = $this->transform()->resourceWith($entity, $transformer)->usingPaginatorIfPaged();

		if ($serializer) {
			return $results->serialize($serializer);
		}

		return $results->serialize();
	}
292816
public function availableIncludeKeys(): array
    {
        $availableKeys = [];
        if (($transformer = $this->transformer()) !== null && ($transformer instanceof  TransformerInterface)) {
            $availableKeys = $transformer->getAvailableIncludes();
        }

        return $availableKeys;
    }
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));
    }
178435
def _get_transformers(self):
        
        transformer_dict = {}

        for table in self.metadata['tables']:
            table_name = table['name']

            for field in table['fields']:
                transformer_type = field.get('type')
                if transformer_type:
                    col_name = field['name']
                    transformer_dict[(table_name, col_name)] = transformer_type

        return transformer_dict
931998
private function simpleTransformations()
    {
        $transformations = array();
        $transformations[] = 'Behat\Behat\Transformation\Transformation\RowBasedTableTransformation';
        $transformations[] = 'Behat\Behat\Transformation\Transformation\ColumnBasedTableTransformation';
        $transformations[] = 'Behat\Behat\Transformation\Transformation\TableRowTransformation';

        if (PHP_VERSION_ID >= 70000) {
            $transformations[] = 'Behat\Behat\Transformation\Transformation\TokenNameAndReturnTypeTransformation';
            $transformations[] = 'Behat\Behat\Transformation\Transformation\ReturnTypeTransformation';
        }

        $transformations[] = 'Behat\Behat\Transformation\Transformation\TokenNameTransformation';

        return $transformations;
    }