Creates and returns HttpTransportOptions from the given connection parameters.

@param parameters
the connection parameters
@return the HttpTransportOptions
489341
private static HttpTransportOptions getHttpTransportOptions(ConnectionParameters parameters) {
    HttpTransportOptions.Builder httpOptionsBuilder = HttpTransportOptions.newBuilder();
    httpOptionsBuilder.setConnectTimeout(parameters.getConnectionTimeout());
    httpOptionsBuilder.setReadTimeout(parameters.getReadTimeout());

    HttpTransportFactory httpTransportFactory = parameters.getHttpTransportFactory();
    if (httpTransportFactory != null) {
      httpOptionsBuilder.setHttpTransportFactory(httpTransportFactory);
    }
    return httpOptionsBuilder.build();
  }
1309549
public static WebsocketClientTransport create(int port) {
    TcpClient client = TcpClient.create().port(port);
    return create(client);
  }
16376
public static void options(HttpConsumer<HttpExchange> endpoint, MediaTypes... mediaTypes) {
        addResource(Methods.OPTIONS, HandlerUtil.BASE_PATH, endpoint, mediaTypes);
    }
753298
function HttpConnection(options) {
    options = options ?
        ({
            protocol: (options.protocol || 'http:'),
            host: (options.host || 'localhost'),
            port: (options.port || '80'),
            path: httpPath,
            withCredentials: false
        }) :
        ({
            path: 'http://localhost:80' + httpPath
        });
    this.options = util._extend({
        localAddress: process.env.LOCAL_ADDRESS
    }, options);
    this._config = JSON.stringify(this.options);
    if (logger.isDebugEnabled()) {
        logger.debug('created with %s', this._config);
    }
}
1062205
public static WebsocketClientTransport create(TcpClient client) {
    Objects.requireNonNull(client, "client must not be null");

    return create(HttpClient.from(client), DEFAULT_PATH);
  }
819518
public RemediationConfiguration withParameters(java.util.Map<String, RemediationParameterValue> parameters) {
        setParameters(parameters);
        return this;
    }
741004
public static WebsocketClientTransport create(URI uri) {
    Objects.requireNonNull(uri, "uri must not be null");

    TcpClient client = createClient(uri);
    return create(HttpClient.from(client), uri.getPath());
  }
1253645
public static void options(String url, HttpConsumer<HttpExchange> endpoint, MediaTypes... mediaTypes) {
        addResource(Methods.OPTIONS, url, endpoint, mediaTypes);
    }
1148242
public static Parameters mergeParams(Parameters... parameters) {
		AnyValueMap map = AnyValueMap.fromMaps(parameters);
		return new Parameters(map);
	}
322183
public TemplateBuilder parameters(Map<String, String> parameters) {
		action.getParameter().putAll(parameters);
		return this;
	}
1073434
public Transport newTransport(ApitraryApi apitraryApi, Class<Transport> transportClazz) {
		try {
			Transport transport = transportClazz.newInstance();
			transport.setApitraryApi(apitraryApi);
			return transport;
		} catch (IllegalAccessException e) {
			throw new ApiTransportException(e);
		} catch (InstantiationException e) {
			throw new ApiTransportException(e);
		}
	}
1045756
public void setTransportParam(String transport) {
		try {
			getSipURI().setParameter(TRANSPORT, transport);
			super.parameters.put(TRANSPORT, transport);
		} catch (ParseException e) {
			logger.error("error setting transport ", e);
		}
	}
302315
public static PageParameters toPageParameters(final Map<String, String> parameters)
	{
		final PageParameters param = new PageParameters();
		for (final Entry<String, String> parameter : parameters.entrySet())
		{
			param.add(parameter.getKey(), parameter.getValue());
		}
		return param;
	}
688487
public static Map<String, String> getRequestParameters(HttpServerExchange exchange) {
        Objects.requireNonNull(exchange, Required.HTTP_SERVER_EXCHANGE.toString());

        final Map<String, String> requestParamater = new HashMap<>();
        final Map<String, Deque<String>> queryParameters = exchange.getQueryParameters();
        queryParameters.putAll(exchange.getPathParameters());
        queryParameters.entrySet().forEach(entry -> requestParamater.put(entry.getKey(), entry.getValue().element()));

        return requestParamater;
    }
997827
public static function create($options = [], TransportInterface $transport = null)
    {
        $transport = $transport ?: static::getTransport();
        $options   = $options ?: static::getOptions();

        switch ($transport) {
            case 'mock':
                $mockOptions = isset($options['mock']) ? $options['mock'] : [];

                $transport = new StreamTransport($mockOptions);
                break;
            case 'stream':
                $streamOptions = isset($options['stream']) ? $options['stream'] : [];

                $transport = new StreamTransport($streamOptions);
                break;

            case 'curl':
            default:
                $curlOptions = isset($options['curl']) ? $options['curl'] : [];

                $transport = new CurlTransport($curlOptions);
                break;
        }

        return new HttpClient($options, $transport);
    }
297860
@NotNull
    protected Map<String, Object> toParameterTypes(ParameterElement... parameters) {
        final LinkedHashMap<String, Object> map = new LinkedHashMap<>(parameters.length);
        for (ParameterElement ce : parameters) {
            final ClassElement type = ce.getType();
            if (type == null) {
                continue;
            }
            final Type typeReference = getTypeForElement(type);
            map.put(ce.getName(), typeReference);
        }

        return map;
    }
847908
public TransportApiResult<List<Stop>> getStops(StopQueryOptions options)
    {
    	if (options == null)
    	{
    		options = StopQueryOptions.defaultQueryOptions();
    	}
    	
    	return TransportApiClientCalls.getStops(tokenComponent, settings, options, null, null, null);
    }