prepare to resolve path parameters
@param parameterResolveFactory
@param param
@param route
@param args
353004
@Override
    public void dispatch(ParameterResolveFactory parameterResolveFactory, ActionParam param, Route route, Object[] args) {
        if (!route.isRegex()) return;

        Matcher matcher = route.getMatcher();
        String[] pathParameters = new String[matcher.groupCount()];
        for (int i = 1, len = matcher.groupCount(); i <= len; i++) {
            pathParameters[i - 1] = matcher.group(i);
        }
        Map<String, String> path = new HashMap<>();
        route.getRegexRoute().getNames().forEach(name -> CollectionKit.MapAdd(path, name, matcher.group(name)));
        param.getRequest().setPathNamedParameters(path);
        param.getRequest().setPathParameters(pathParameters);
    }
948888
@Override
  public S handle(int version, Route route, Properties parms, String postBody) throws Exception {
    // Peek out the desired algo from the URL
    String ss[] = route._url.split("/");
    String algoURLName = ss[3]; // {}/{3}/{ModelBuilders}/{gbm}/{parameters}
    String algoName = ModelBuilder.algoName(algoURLName); // gbm -> GBM; deeplearning -> DeepLearning
    String schemaDir = ModelBuilder.schemaDirectory(algoURLName);

    // Build a Model Schema and a ModelParameters Schema
    String schemaName = schemaDir+algoName+"V"+version;
    S schema = (S) TypeMap.newFreezable(schemaName);
    schema.init_meta();
    String parmName = schemaDir+algoName+"V"+version+"$"+algoName+"ParametersV"+version;
    P parmSchema = (P)TypeMap.newFreezable(parmName);
    schema.parameters = parmSchema;

    // Only here for train or validate-parms
    String handlerName = route._handler_method.getName();
    boolean doTrain = handlerName.equals("train");
    assert doTrain || handlerName.equals("validate_parameters");

    // User specified key, or make a default?
    String model_id = parms.getProperty("model_id");
    String warningStr = null;
    if ((model_id != null) && (model_id.contains("/"))) { // found / in model_id, replace with _ and set warning
      String tempName = model_id;
      model_id = model_id.replaceAll("/", "_");
      warningStr = "Bad model_id: slash (/) found and replaced with _.  " + "Original model_id "+tempName +
              " is now "+model_id+".";
      Log.warn("model_id", warningStr);
    }
    Key<Model> key = doTrain ? (model_id==null ? ModelBuilder.defaultKey(algoName) : Key.<Model>make(model_id)) : null;
    // Default Job for just this training
    Job job = doTrain ? (warningStr!=null ? new Job<>(key,ModelBuilder.javaName(algoURLName),algoName, warningStr) :
            new Job<>(key,ModelBuilder.javaName(algoURLName),algoName)) : null;
    // ModelBuilder
    B builder = ModelBuilder.make(algoURLName,job,key);

    schema.parameters.fillFromImpl(builder._parms); // Defaults for this builder into schema
    schema.parameters.fillFromParms(parms);         // Overwrite with user parms
    schema.parameters.fillImpl(builder._parms);     // Merged parms back over Model.Parameter object
    builder.init(false);          // validate parameters
    schema.fillFromImpl(builder); // Fill in the result Schema with the Job at least, plus any extra trainModel errors
    PojoUtils.copyProperties(schema.parameters, builder._parms, PojoUtils.FieldNaming.ORIGIN_HAS_UNDERSCORES, null, new String[] { "error_count", "messages" });
    schema.setHttpStatus(HttpResponseStatus.OK.getCode());
    if( doTrain ) schema.job.fillFromImpl(builder.trainModelOnH2ONode());
    return schema;
  }
967103
private void validateParameterResolvers(MethodTarget methodTarget) {
		Utils.createMethodParameters(methodTarget.getMethod())
				.forEach(parameter -> {
					parameterResolvers.stream()
							.filter(resolver -> resolver.supports(parameter))
							.findFirst()
							.orElseThrow(() -> new ParameterResolverMissingException(parameter));
				});
	}
742006
function (route, parameters) {

        return new Promise((resolve, reject) => {

            request.get({
                url: baseUrl + route + '?' + querystring.stringify(parameters)
            }, (error, response, body) => {

                if (error) {
                    reject(error);
                } else if (response && body) {
                    var result;

                    try {
                        result = JSON.parse(body);
                    } catch (e) {
                        reject(e);
                    }

                    if (result.error == 'Method not allowed') {
                        this._post(route, parameters).then(
                            res => { resolve(res) },
                            err => { reject(err) }
                        );
                    } else {
                        resolve(result);
                    }
                } else {
                    reject(response);
                }
            });
        });
    }
191133
function Request__resolveRoute(routeRule) {
        var route;
        this.route = routeRule.shift();
        this.params = routeRule.shift();
        route = this.route.split('/');
        if (route.length === 3) {
            this.module = route.shift();
        }
        this.controller = route.shift();
        this.action = route.shift();

        if (!!this.module) {
            return this._handleModule(di.getAlias('modulesPath'));
        }

        return this._handleController(di.getAlias('controllersPath'), di.getAlias('viewsPath'));
    }
292152
static synchronized BeanFactoryId register(Class<?> clazz, Set<String> pathParams,
                                               List<RequestObjectResolver> objectResolvers) {
        final BeanFactoryId beanFactoryId = new BeanFactoryId(clazz, pathParams);
        if (!factories.containsKey(beanFactoryId)) {
            final AnnotatedBeanFactory<Object> factory = createFactory(beanFactoryId, objectResolvers);
            if (factory != null) {
                factories.put(beanFactoryId, factory);
                logger.debug("Registered a bean factory: {}", beanFactoryId);
            } else {
                factories.put(beanFactoryId, unsupportedBeanFactory);
            }
        }
        return beanFactoryId;
    }
815799
void resolveTypeVariable(SQLiteModelMethod value) {
		// before proceed, we need to resolve typeVariables
		for (Pair<String, TypeName> item : value.getParameters()) {
			item.value1 = typeVariableResolver.resolve(item.value1);
		}

		value.setReturnClass(typeVariableResolver.resolve(value.getReturnClass()));

	}
570740
function resolve(path, options, callback) {
        resolvePath(path, options, function (err, path) {
            if (err) return callback(err);
            callback(null, { path: path });
        });
    }
512460
public static void saveVMParameters(String classToLaunch, String... parameters) {
		classnameToLaunch = classToLaunch;
		commandLineParameters = parameters;
		if (commandLineOptions != null) {
			commandLineOptions.clear();
		}
		commandLineOptions = null;
		analyzed = false;
	}
1163293
public URL[] resolveToURLs(GAV gav) throws IOException, RepositoryException {
        List<URL> jars = new ArrayList<URL>();
        for (File f : resolve(gav)) {
            jars.add(f.toURI().toURL());
        }
        return jars.toArray(new URL[jars.size()]);
    }
850023
@SuppressWarnings("unchecked")
    protected @Nullable Object doResolve(
            ArgumentConversionContext<T> context,
            ConvertibleValues<?> values,
            String annotationValue) {

        Object value = resolveValue(context, values, annotationValue);
        if (value == null) {
            String fallbackName = getFallbackFormat(context.getArgument());
            if (!annotationValue.equals(fallbackName)) {
                annotationValue = fallbackName;
                value = resolveValue(context, values, annotationValue);
            }
        }

        return value;
    }
299058
function generatePath(route, params) {
    return route.pattern.replace(nameOrSplatParam, function(_, name) { return params[name]; });
  }
7646
public void init(final ConstraintValidatorFactory factory,
      final MessageInterpolator messageInterpolator, final TraversableResolver traversableResolver,
      final ParameterNameProvider pparameterNameProvider) {
    contraintValidatorFactory = factory;
    this.messageInterpolator = messageInterpolator;
    this.traversableResolver = traversableResolver;
    parameterNameProvider = pparameterNameProvider;
  }
1208598
@Override
    public FileModel resolvePayload(GraphRewrite event, EvaluationContext context, WindupVertexFrame payload)
    {
        checkVariableName(event, context);
        if (payload instanceof FileReferenceModel)
        {
            return ((FileReferenceModel) payload).getFile();
        }
        if (payload instanceof FileModel)
        {
            return (FileModel) payload;
        }
        return null;
    }
646892
private function resolveRoute($route_handle, $route_parameters)
    {
        $list = $this->getRouteList();
        $generator = $this->getGenerator();

        if ($route = $list->get($route_handle)) {
            if ($path = $generator->generate($route_handle, $route_parameters, UrlGeneratorInterface::ABSOLUTE_PATH)) {
                return $this->pathUrlResolver->resolve(array($path));
            }
        }
    }
714164
def start
      resolve_parameters

      version_info = version_info @service, @version
      env_variables = version_info["envVariables"] || {}
      beta_settings = version_info["betaSettings"] || {}
      cloud_sql_instances = beta_settings["cloud_sql_instances"] || []
      image = version_info["deployment"]["container"]["image"]

      config = build_config command, image, env_variables, cloud_sql_instances
      file = ::Tempfile.new ["cloudbuild_", ".json"]
      begin
        ::JSON.dump config, file
        file.flush
        Util::Gcloud.execute [
            "builds", "submit",
            "--no-source",
            "--config=#{file.path}",
            "--timeout=#{@timeout}"]
      ensure
        file.close!
      end
    end
460365
function PathPattern(options) {
    // The route string are compiled to a regexp (if it isn't already)
    this.regexp = options.regexp;

    // The query parameters specified in the path part of the route
    this.params = options.params;

    // The original routestring (optional)
    this.routeString = options.routeString;
  }