@param string $name

@return DenormalizationFieldMappingBuilderInterface
506770
public static function createDateTime(
        string $name,
        bool $emptyToNull = false
    ): DenormalizationFieldMappingBuilderInterface {
        $self = new self($name);
        $self->fieldDenormalizer = new DateTimeFieldDenormalizer(new PropertyAccessor($name), $emptyToNull);

        return $self;
    }
364797
public function getField($name)
    {
        if (array_key_exists($name, $this->fields)) {
            return $this->fields[$name];
        }
        else if (array_key_exists($name, $this->fieldAliases)) {
            $name = $this->fieldAliases[$name];
            return $this->fields[$name];
        }
        return null;
    }
908830
public function getField($name)
    {
        return (null !== $name && array_key_exists($name, $this->fields)) ? $this->fields[$name] : null;
    }
520021
public function getField( $name )
	{
		if( !$this->hasField( $name ) )
			return NULL;
		$values	= $this->getFieldsByName( $name );
		return array_shift( $values );
	}
141487
public static function buildIDField($name) {
		$field				= new static($name, 'ref');
		$TYPE				= $field->getType();
		$field->args		= $TYPE->parseArgs(array());
		$field->default		= null;
		$field->writable	= false;
		$field->nullable	= false;
		return $field;
	}
834740
private function buildDefinitionBuilderNode($name)
    {
        $node = new ArrayNodeDefinition($name);

        $node
            ->children()
                ->booleanNode('public')
                    ->defaultFalse()
                    ->treatNullLike(false)
                ->end()
            ->end()
        ;

        return $node;
    }
32390
public function getAnnotation($name)
    {
        return $this->annotations
            ->map(
                function (ArrayMap $value) use ($name) {
                    return $value->lookup($name);
                }
            )
            ->filter(
                function (Maybe $value) {
                    return $value->isJust();
                }
            )
            ->map(
                function (Maybe $value) {
                    return Maybe::fromJust($value);
                }
            );
    }
183162
protected function denormalizeProperty($data, $class, $name, $format = null, array $context = array())
    {
        if (!$this->propertyInfoExtractor) {
            return $data;
        }

        /** @var Type[] $types */
        $types = (array) $this->propertyInfoExtractor->getTypes($class, $name);
        $_class = null;
        $_class = array_reduce(
            $types,
            function($class, Type $type) {
                return $class ?: $type->getClassName();
            },
            $_class
        );

        if ($data === null and $_class === null) {
            return $data;
        }

        if (!$this->serializer instanceof DenormalizerInterface) {
            $message = 'Cannot denormalize attribute "%s" because injected serializer is not a denormalizer';
            throw new RuntimeException(sprintf($message, $name));
        }

        if ($_class === null
            or !$this->serializer->supportsDenormalization($data, $_class, $format, $context)) {
            return $data;
        }

        return $this->serializer->denormalize($data, $_class, $format, $context);
    }
995178
public function bindMap(string $name): MapBinding
    {
        if (!isset($this->mapBindings[$name])) {
            $this->mapBindings[$name] = $this->addBinding(new MapBinding($name));
        }

        return $this->mapBindings[$name];
    }
654272
public function getField($name)
    {
        $result = null;
        foreach ($this->fields as $key => $fields) {
            if (isset($fields[$name])) {
                $result = $fields[$name];
            }
        }
        return $result;
    }
1335833
public static function createReferenceMany(
        string $name,
        string $idName = 'id'
    ): NormalizationFieldMappingBuilderInterface {
        $self = new self($name);
        $self->fieldNormalizer = new ReferenceManyFieldNormalizer(
            new PropertyAccessor($idName),
            new PropertyAccessor($name)
        );

        return $self;
    }
1125306
public function getField($name)
    {
        if ('pk' === $name) {
            $name = $this->getPrimaryKeyName();
        }

        $name = $this->getMappingName($name);

        if (isset($this->fields[$name])) {
            $field = $this->fields[$name];
            $field->cleanValue();

            return $field;
        }
    }
156434
public function get($name)
    {
        if (array_key_exists($name, $this->transformations)) {
            return $this->transformations[$name];
        }

        throw new \InvalidArgumentException(
            sprintf(
                'A image transformation transformation named "%s" does not exist.',
                $name
            )
        );
    }
38568
public function field($name = null, $flatten = false)
	{
		return $this->fieldset->field($name, $flatten);
	}
530125
private function build(string $name)
    {
        $instance = null;
        $map = $this->map[$name];

        if (is_array($map)) {
            $params = $this->getParamsFromMap($map);
            $instance = new $name(...$params);
        } elseif ($map instanceof \Closure) {
            $instance = $map($this);
        } elseif (is_object($map)) {
            $instance = $map;
        } elseif (is_string($map)) {
            $instance = $this->get($map);
        } else {
            throw new \Exception('Invalid map');
        }

        return $instance;
    }
176408
public static function entityManager($name = 'default')
    {
        if (isset(self::$entityManagers[$name])) {
            return self::$entityManagers[$name];
        }
        $databaseConnection = self::connection($name)->getDbalConnection();

        if (Configuration::get('app.env') == 'development') {
            $cache = new ArrayCache();
        } else { // @codeCoverageIgnore
            $cache = new FilesystemCache(Configuration::get('app.cache')); // @codeCoverageIgnore
        }

        $config = new \Doctrine\ORM\Configuration();
        $config->setMetadataCacheImpl($cache);
        $driver = $config->newDefaultAnnotationDriver([APPPATH . 'Entity'], false);

        $config->setMetadataDriverImpl($driver);
        $config->setQueryCacheImpl($cache);

        $proxyDir = APPPATH . 'Proxy';
        $proxyNamespace = 'App\Proxy';

        $config->setProxyDir($proxyDir);
        $config->setProxyNamespace($proxyNamespace);
        Autoloader::register($proxyDir, $proxyNamespace);

        $loggerChain = new LoggerChain();
        if (Configuration::get('app.env') == 'development') {
            $config->setAutoGenerateProxyClasses(true);

            $loggerChain->addLogger(new DoctrineLogBridge(\Logger::getInstance()->getMonologInstance()));
            $loggerChain->addLogger(DebugBarHelper::getInstance()->getDebugStack());
        } else { // @codeCoverageIgnore
            $config->setAutoGenerateProxyClasses(false); // @codeCoverageIgnore
        }
        $em = EntityManager::create($databaseConnection, $config);

        $em->getConnection()->getConfiguration()->setSQLLogger($loggerChain);
        $em->getConfiguration()->setSQLLogger($loggerChain);

        self::$entityManagers[$name] = $em;
        return $em;
    }
193315
public function removeFieldByName($name)
    {
        foreach ($this->fields as $i => $field) {
            if ($field->getName() == $name) {
                unset($this->fields[$i]);
                break;
            }
        }

        return $this;
    }