@param string $name

@return \marvin255\serviform\interfaces\HasChildren
547180
public function unsetElement($name)
    {
        if (isset($this->elements[$name])) {
            unset($this->elements[$name]);
        }

        return $this;
    }
934309
public static function get($name)
    {
        if (!isset(static::$types[$name])) {
            if (!static::has($name)) {
                throw new \InvalidArgumentException(sprintf('The type "%s" does not exists.', $name));
            }

            static::$types[$name] = new static::$map[$name];
        }

        return static::$types[$name];
    }
1305508
public function hasHeader($name)
    {
        $name = strtolower($name);
        if (!$this->request) {
            return $this->getRequest()->hasHeader($name);
        }
        return parent::hasHeader($name);
    }
816906
public function menu($name)
    {
        if (array_key_exists($name, $this->menus)) {
            return $this->menus[$name];
        }

        return $this->menus[$name] = new MenuBuilder($name, $this->config);
    }
393856
public function hasGroup($name)
    {
        if ($name instanceof GroupInterface) {
            return $this->groups->contains($name);
        }

        return $this->groups->containsKey($name);
    }
1108662
public function children($name = null)
    {
        if (!$name) {
            return $this->getStructures();
        }

        $result = [];
        foreach ($this->getStructures() as $childStructure) {
            if ($childStructure->getParentName() === $name) {
                $result[] = $childStructure;
            } else {
                $localResult = $childStructure->children($name);
                if ($localResult) {
                    $result = array_merge($result, $localResult);
                }
            }
        }

        if (!count($result)) {
            return null;
        }

        return $result;
    }
217001
public function getChild($name)
    {
        $path = $this->path.'/'.$name;

        if (!file_exists($path)) {
            throw new DAV\Exception\NotFound('File could not be located');
        }
        if ('.' == $name || '..' == $name) {
            throw new DAV\Exception\Forbidden('Permission denied to . and ..');
        }
        if (is_dir($path)) {
            return new self($path);
        } else {
            return new File($path);
        }
    }
132636
public function byName($name) {
		if($this->loaded == false) {
			$this->getIterator();
		}

		if(isset($this->items[$name])) return $this->items[$name];
	}
580323
public function get($name)
    {
        return ($this->session->has($name)) ? $this->session->get($name) : '';
    }
121823
public function getChild($name)
    {
        $path = $this->path.'/'.$name;

        if (!file_exists($path)) {
            throw new NotFound('File could not be located');
        }
        if ('.' == $name || '..' == $name) {
            throw new Forbidden('Permission denied to . and ..');
        }
        if (is_dir($path)) {
            return new self($path, $this->acl, $this->owner);
        } else {
            return new File($path, $this->acl, $this->owner);
        }
    }
22119
public static function get($name)
    {
        $class = get_called_class();
    
        if (!isset(self::$instance[$class])) {
            self::$instance[$class] = new static();
        }
        
        return self::$instance[$class]->getExtensions()->get($name);
    }
1170931
protected function getParentClasses($name)
    {
        // Collect parent classes, ignoring transient (not-mapped) classes.
        $parentClasses = array();
        foreach (array_reverse(class_parents($name)) as $parentClass) {
            if (!$this->driver->isTransient($parentClass)) {
                $parentClasses[] = $parentClass;
            }
        }
        return $parentClasses;
    }
361032
public function getChildByName($name) {
		foreach($this->getChildren() as $child) {
			if($child->getName() == $name) return $child;
		}

		return false;
	}
895217
public function queue($name)
    {
        if (!isset($this->queues[$name])) {
            $this->queues[$name] = new Queue($this, $name);
        }
        return $this->queues[$name];
    }
554739
public static function missing(string $name): self
    {
        $e = sprintf(parent::MISSING, $name);

        return new static($e);
    }
107893
private function resolveChild($name)
    {
        $info = $this->unresolvedChildren[$name];
        $child = $this->create($name, $info['type'], $info['options']);
        $this->children[$name] = $child;
        unset($this->unresolvedChildren[$name]);

        return $child;
    }
1045882
final public static function byName(string $name)
    {
        if (isset(self::$instances[static::class][$name])) {
            return self::$instances[static::class][$name];
        }

        $const = static::class . "::{$name}";
        if (!\defined($const)) {
            throw new InvalidArgumentException("{$const} not defined");
        }

        return self::$instances[static::class][$name] = new static(\constant($const));
    }