{@inheritDoc}
@see \Seeren\Router\Factory\RouteFactoryInterface::create()
165805
public function create(
       string $action,
       string $prefix,
       string $controller,
       array $param,
       string $path): RouteInterface
   {
       try {
           return $this->proto->clone()
               ->setAction($action)
               ->setPrefix($prefix)
               ->setController($controller)
               ->setParam($param)
               ->setPath($path);
       } catch (InvalidArgumentException $e) {
           throw new InvalidArgumentException(
               "Can't create route: " . $e->getMessage());
       }
   }
852164
public function create(FieldCreator $listener, Route $route)
    {
        $eloquent = Foundation::make('antares.customfields.model');
        $form     = $this->presenter->form($eloquent, 'create', $route);
        $this->fireEvent('form', [$eloquent, $form]);
        return $listener->showFieldCreator(compact('eloquent', 'form'));
    }
131081
public function create($key , $value=null) {

		if($this->check_path()) {
			return CoreManager::create($this->path,$key,$value);	
		}

		return false;
		
	}
801339
public function getCreateRoute()
    {
        if (null === $this->createRoute) {
            $route = rtrim($this->getBaseRoute(), '/') . '/' . $this->getCreateSuffix();
            $this->setCreateRoute($route);
        }

        return $this->createRoute;
    }
109180
private function _createRoute( $options )
    {
        $url = $this->_di->getService( "url" );

        /**
         * All route uris should have the uri prefix
         */
        $options["uri"] = $url->getUriPrefix() . $options["uri"];

        if (isset($options["controller_action"]))
        {
            $controller_action_exploded = explode( "#", $options["controller_action"] );

            $options["controllerName"] = $controller_action_exploded[0];
            $options["actionName"]     = $controller_action_exploded[1];
        }

        // $uri            = $settings["uri"];
        //
        // $controllerName = $settings["controllerName"];
        //
        // $actionName     = $settings["actionName"];
        //
        // $params         = $settigns["params"];

        return new Route($options);
    }
1369502
public function create(
        string $method,
        string $definition,
        RequestHandlerInterface $handler,
        ?string $name,
        $data
    ): Route {
        if (!Method::isValid($method)) {
            throw InvalidRoute::invalidMethod($method);
        }

        $path = $this->parser->parse($definition, $this->types);

        return new Route($method, $path, $handler, $name, $data);
    }
250157
protected function createRoute(RouteInterface $route, Request $request)
    {
        $routePath = $this->decodePathInfo($request->getPathInfo());

        if ($route->isHistory()) {
            return new Route(
                $routePath,
                [
                    '_controller' => 'SuluWebsiteBundle:Redirect:redirect',
                    'url' => $request->getSchemeAndHttpHost()
                        . $this->requestAnalyzer->getResourceLocatorPrefix()
                        . $route->getTarget()->getPath()
                        . ($request->getQueryString() ? ('?' . $request->getQueryString()) : ''),
                ]
            );
        }

        $symfonyRoute = $this->proxyFactory->createProxy(
            Route::class,
            function(&$wrappedObject, LazyLoadingInterface $proxy, $method, array $parameters, &$initializer) use (
                $routePath,
                $route,
                $request
            ) {
                $initializer = null; // disable initialization
                $wrappedObject = new Route(
                    $routePath,
                    $this->routeDefaultsProvider->getByEntity(
                        $route->getEntityClass(),
                        $route->getEntityId(),
                        $request->getLocale()
                    )
                );

                return true;
            }
        );

        return $this->symfonyRouteCache[$route->getId()] = $symfonyRoute;
    }
1012816
public function create($uri)
    {
        list($scheme, $host, $port, $path, $query, $fragment, $user, $pass) = $this->parseUrl($uri);

        return new Uri($scheme, $host, $port, $path, $query, $fragment, $user, $pass);
    }
948747
public function createNewAlias($alias, $path, array $pathParameters = array(), $locale = null, $title = null, $keywords = null, $description = null)
    {
        $rc = new \ReflectionClass($this->entityClass);
        $object = $rc->newInstance();
        if (!$object instanceof ContentInterface) {
            return;
        }
        $object->setAlias($alias);
        $pathParameters[UrlGenerator::GENERATE_NORMAL_ROUTE] = true;
        $path = $this->router->generate($path, $pathParameters);
        $path = str_replace('/app_dev.php', '', $path);
        $key = $this->generator->generateMetaTagKeyFromRelativePath($path, $this->router, $locale);
        $object->setKeyword($key);
        $object->setTitle($title);
        $object->setKeywords($keywords);
        $object->setDescription($description);

        return $object;
    }
1326862
public static function create(Loader $configuration = null, EngineFactory $engineFactory = null)
    {
        return new self($configuration, $engineFactory);
    }
182117
public static function create()
    {
        $request = self::makeRequest();
        $response = self::makeResponse();

        return self::buildProvidersContainer($request, $response);
    }
788404
public static function create($path = 'Staq\Core\Ground', $baseUri = NULL, $platform = NULL)
    {
        return (new \Staq\Server)->createApplication($path, $baseUri, $platform);
    }
888047
public function create($routeName, array $data = array(), array $query = array())
    {
        return $this->createUrl(parent::create($routeName, $data, $query));
    }
181163
public function createRoute(InputInterface $input, OutputInterface $output)
    {
        $router = $this->getApplication()->find('create:router');
        $router_arguments = array(
            'command'       => 'create:router',
            'module'        => $input->getArgument('module'),
            'controller'    => $input->getArgument('table'),
            'action'        => 'index'
        );
        $input_router = new ArrayInput($router_arguments);
        $return_router = $router->run($input_router,$output);
        return $output->writeln($return_router);
    }
1252425
public function actionCreate()
    {
        Yii::$app->getResponse()->format = 'json';
        $routes = Yii::$app->getRequest()->post('route', '');
        $routes = preg_split('/\s*,\s*/', trim($routes), -1, PREG_SPLIT_NO_EMPTY);
        $this->saveNew($routes);
        Helper::invalidate();
        return $this->getRoutes();
    }
1219259
public static function createRequest($method, $uri)
    {
        if (! static::$requestFactory) {
            static::$requestFactory = new RequestFactory();
        }

        return static::$requestFactory->createRequest($method, $uri);
    }
220119
public static function create(?TypeCollection $types = null): self
    {
        $types = $types ?? TypeCollection::createDefault();

        $parser = new Parser();

        $factory = new RouteFactory($parser, $types);

        return new self($factory);
    }