Get a registered component path

@param string $name    The component name
@param string $domain  The component domain. Domain is optional and can be NULL
@return string Returns the component path if the component is registered. FALSE otherwise
965761
public function getComponentPath($name, $domain = null)
    {
        $result = null;

        $identifier = $this->getComponentIdentifier($name, $domain);
        if(isset($this->_components[$identifier])) {
            $result = $this->_components[$identifier];
        }

        return $result;
    }
757749
public function getDomainComponent()
    {
        $component = $this;
        while ($component) {
            $class = $component->componentClass;
            if (Kwc_Abstract::hasSetting($class, 'baseProperties') &&
                in_array('domain', Kwc_Abstract::getSetting($class, 'baseProperties'))
            ) {
                return $component;
            }
            $component = $component->parent;
        }
    }
769440
public function getComponent(string $name) : Component
    {
        if (isset($this->components[$name])) {
            return $this->components[$name];
        }

        throw new \RuntimeException(sprintf('No component named "%s"', $name));
    }
1032533
public function getRouteByAlias($name)
    {
        $aliases = $this->getAliases();

        return isset($aliases[$name]) ? $aliases[$name] : NULL;
    }
1356296
public function domain($domain = null) {

		if(null !== $domain) {

			if(false === is_string($domain)) {
				return trigger_error(sprintf('Argument 1 passed to %s() must be of the type string, "%s" given', __METHOD__, gettype($domain)), E_USER_ERROR);
			}

			//Check if identifier exists
			if(false === Router :: routeExists($this -> identifier, $domain)) {
				return trigger_error(sprintf('Identifier "%s" with domain "%s" does not exists', $this -> identifier, $domain), E_USER_ERROR);	
			}

			$this -> domain = $domain;
		}

		return $this;
	}
80649
public static function getByDomain($domain)
    {
        // Map true -> actual domain
        if ($domain === true) {
            $state = FluentState::singleton();
            $domain = $state->getIsDomainMode() ? $state->getDomain() : null;
        }

        // No domain found
        if (!$domain) {
            return null;
        }

        if ($domain instanceof Domain) {
            return $domain;
        }

        // Get filtered domain
        return static::getCached()
            ->filter('Domain', $domain)
            ->first();
    }
1255886
public function findOrFail($name)
    {
        $component = $this->find($name);

        if ($component !== null) {
            return $component;
        }

        throw new ComponentNotFoundException("Component [{$name}] does not exist!");
    }
1189822
public function getComponent($name)
    {
        if (!isset($this->componentCache[$name]) && ($this->componentCache[$name]
            = $this->createComponent($name)) !== null) {
            $this->componentCache[$name]->init();
        }

        return $this->componentCache[$name];
    }
820084
protected function getResourceOwnerCheckPath($name)
    {
        foreach ($this->ownerMaps as $ownerMap) {
            if ($potentialResourceOwnerCheckPath = $ownerMap->getResourceOwnerCheckPath($name)) {
                return $potentialResourceOwnerCheckPath;
            }
        }

        return null;
    }
545892
protected function getPath($name)
    {
        $name = Str::replaceFirst($this->rootNamespace(), '', $name);

        return $this->plugin->app_path.'/'.str_replace('\\', '/', $name).'.php';
    }
283253
public function getDomainInfo($domain)
    {
        try {
            $result = $this->getDomainLookupQuery($domain)->getSingleResult();
        } catch (NoResultException $e) {
            $result = null;
        }

        return $result;
    }
918304
public function getComponents($domain = null)
    {
        $components = $result = array_keys($this->_components);

        if($domain)
        {
            foreach($components as $key => $component)
            {
                if(strpos($component, 'com://'.$domain) === false) {
                    unset($components[$key]);
                }
            }
        }

        return $components;
    }
1086902
public function getComponentDomain($name)
    {
        $result = null;

        if(isset($this->_domains[$name])) {
            $result = $this->_domains[$name];
        }

        return $result;
    }
691927
public function getPath($name)
    {
        $segments = explode('\\', $name);

        array_shift($segments);
        if($this->path)
            return $this->path.'/'.ucfirst(array_last($segments)).'Factory.php';
        else
            return database_path('factories/'.ucfirst(array_last($segments))).'Factory.php';

    }
386480
public function getConfFilePath($name)
    {
        ($this->apache_base_path != null) ? $apache_base_path = $this->getPath($this->apache_base_path) :
            $apache_base_path = $this->getPath("/etc/apache2/");

        $suffix = "";
        if ($this->apache_version === "24") {
            $suffix = '/conf-available/' . $name . '.conf';
        } else {
            $suffix = '/conf.d/' . $name . '.conf';
        }

        return $apache_base_path . $suffix;

    }
1275644
public static function getRegisteredName(string $name): string
    {
        $key = strtolower($name);

        return isset(self::$headers[$key]) ? self::$headers[$key]['name'] : $name;
    }
69277
public function getClassPath($name)
    {
        $name = $this->_formatName($name);
        if ($this->_useStaticRegistry
            && !empty(self::$_staticLoadedPluginPaths[$this->_useStaticRegistry][$name])
        ) {
            return self::$_staticLoadedPluginPaths[$this->_useStaticRegistry][$name];
        } elseif (!empty($this->_loadedPluginPaths[$name])) {
            return $this->_loadedPluginPaths[$name];
        }

        if ($this->isLoaded($name)) {
            $class = $this->getClassName($name);
            $r     = new ReflectionClass($class);
            $path  = $r->getFileName();
            if ($this->_useStaticRegistry) {
                self::$_staticLoadedPluginPaths[$this->_useStaticRegistry][$name] = $path;
            } else {
                $this->_loadedPluginPaths[$name] = $path;
            }
            return $path;
        }

        return false;
    }