Returns the schema definition parser for the <code>name</code> value

@param $name
@return \Neoxygen\Neogen\Parser\ParserInterface
@throws ParserNotFoundException
6274
public function getParser($name)
    {
        if (!$this->hasParser($name)) {
            throw new ParserNotFoundException(sprintf('The parser with NAME "%s" is not registered', $name));
        }

        return $this->parsers[$name];
    }
40032
public function getAppender($name)
    {
        if (!isset($this->appenderMap[$name])) {
            LoggerPolicy::processConfigurationError("Appender {$name} not found");

            return new AppenderNull();
        }

        return $this->appenderMap[$name];
    }
593297
public function getChild(string $name): NodeInterface
    {
        if (!isset($this->nodeChildren[$name])) {
            throw new NotFoundException($name);
        }

        return $this->nodeChildren[$name];
    }
1353864
public function getExtension($name)
    {
        if ($this->hasExtension($name)) {
            return $this->_extensions[$name];
        }

        throw new HandlerNotFoundException(get_class($this).": No extension named \"$name\" found");
    }
1176093
public function getStore( string $name = null ): CacheStoreInterface
	{
		if( is_null($name) )
		{
			$name = "default";
		}

		if( isset($this->store[$name]) || $this->loadStore($name) )
		{
			return $this->store[$name];
		}

		throw new NotFoundException("The '{$name}' cache store config not found");
	}
650507
public function parse($name): Template\Parser
    {
        if ($name instanceof Template\Parser) {
            return $name;
        } elseif (! isset($this->parsers[$name]) && \is_string($name)) {
            $this->name($name, $name);
        }

        $parser = $this->parsers[$name] ?? $name;

        if (! $parser instanceof Template\Parser) {
            throw new InvalidArgumentException(
                "Expected \$parser to be instanceof Orchestra\Facile\Template\Parser."
            );
        }

        return $parser;
    }
1011204
public function get($name)
    {
        $definition = null;
        if ($this->has($name)) {
            $definition = $this->_definitionSource[$this->_names[$name]];
        }
        return $definition;
    }
579158
public function get_by_name( $name )
    {
        $filtered = $this->filter(function($c) use ($name) {
            return $c instanceof ValueComponentInterface && $c->name === $name;
        });
        if(count($filtered) < 1)
        {
            throw new \RuntimeException("No component with the name <b>$name</b> could be found.");
        }
        return $filtered[0];
    }
891513
public function element(string $name): ElementInterface
    {
        if (! isset($this->elements[$name])) {
            throw new ElementNotFoundException(
                sprintf('The element with name <code>%s</code> does not exists', $name)
            );
        }

        return $this->elements[$name];
    }
562333
protected static function schemaBuilder($name = null)
    {
        /**
         * @var $db \Illuminate\Database\DatabaseManager
         */
        $db = static::$app['db'];

        $builder = $db->connection($name)->getSchemaBuilder();

        $builder->blueprintResolver(function ($table, $callback) {
            return new Blueprint($table, $callback);
        });

        return $builder;
    }
908971
protected function parseName($name)
    {
        $rootNamespace = $this->container->getNamespace();

        if (Str::startsWith($name, $rootNamespace)) {
            return $name;
        }

        if (Str::contains($name, '/')) {
            $name = str_replace('/', '\\', $name);
        }

        return $this->parseName($this->getDefaultNamespace(trim($rootNamespace, '\\')) .'\\' .$name);
    }
1229250
public function getRawSQLName($name)
    {
        $names = $this->metadata[Metadata::RAW_NAMES];
        
        if (isset($names[$name]))
            return $names[$name];
        
        throw new NotFoundException('Cannot found real column name for ":name"', ['name' => $name]);
    }
834740
private function buildDefinitionBuilderNode($name)
    {
        $node = new ArrayNodeDefinition($name);

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

        return $node;
    }
1297989
public function getDictionary(string $name): Definition
    {
        if (!$this->hasDictionary($name)) {
            throw new \InvalidArgumentException('Dictionary not found: ' . $name);
        }

        return $this->dictionaries[$name];
    }
29070
public static function getSchema($name) {
        if (!isset(self::$schemas[$name])) {
            try {
                self::$schemas[$name] = Schema::i($name);
            } catch (Exception $e) {
                return false;
            }
        }

        return self::$schemas[$name];
    }
506582
private function processSimpleField($name, Schema\Field $definition)
    {
        if (strpos($definition->getType(), 'class:') === 0) {
            $field = new JsonDefinitionRel($name, $definition, $this->getRelation($name));
        } else {
            $field = new JsonDefinitionField($name, $definition);
        }

        if (substr($definition->getType(), -2) === '[]') {
            $field = new JsonDefinitionArray($name, $field);
        }

        return $field;
    }
1071567
public function getDefinition($name)
    {
        if (!class_exists($name) && !interface_exists($name)) {
            return null;
        }

        $class = new \ReflectionClass($name);
        if(isset($name::$__enableDIAnnotations__) && $name::$__enableDIAnnotations__){
            $context = $this->loader->build($name);
            /**@var $context ObjectDefinitionContext */
            $definition = $context->definition;
        }else{
            $definition = new ObjectDefinition($name);
        }

        $constructor = $class->getConstructor();
        if ($constructor && $constructor->isPublic()) {
            $definition->setConstructorInjection(
                MethodInjection::constructor($this->getParametersDefinition($constructor))
            );
        }

        return $definition;
    }