Define fluent endpoint dispatcher
 @param params [Hash] the parameters
15923
def endpoint(params)
      params.each_pair do |param_name, param_value|
        case param_name
          when :summary
            endpoint_summary param_value
          when :description
            endpoint_description param_value
          when :tags
            endpoint_tags *param_value
          when :produces
            endpoint_produces *param_value
          when :path
            endpoint_path param_value
          when :parameters
            param_value.each do |param, args_param|
              endpoint_parameter param, *args_param
            end
          when :responses
            param_value.each do |code, args_response|
              endpoint_response code, *args_response
            end
          else
            raise SwaggerInvalidException.new("Invalid endpoint parameter [#{param_name}]")
        end
      end
    end
249406
def params
      {}.tap do |param|
        param[:status] = SubscriptionPaymentOrder::STATUSES[status.to_sym]
        param[:page] = page
        param[:maxPageResults] = options[:per_page]
        param[:credentials] = options[:credentials]
      end
    end
1260126
def dispatch_to_controller(params, request)
      namespace = params[:component] || 'main'

      controller_name = params[:controller] + '_controller'
      action = params[:action]

      namespace_module = Object.const_get(namespace.camelize.to_sym)
      klass = namespace_module.const_get(controller_name.camelize.to_sym)
      controller = klass.new(@volt_app, params, request)

      # Use the 'meta' thread local to set the user_id for Volt.current_user
      meta_data = {}
      user_id = request.cookies['user_id']
      meta_data['user_id'] = user_id if user_id
      Thread.current['meta'] = meta_data

      controller.perform(action)
    end
770216
synchronized public void setSSLParameters(SSLParameters params) {
        super.setSSLParameters(params);

        // the super implementation does not handle the following parameters
        identificationProtocol = params.getEndpointIdentificationAlgorithm();
        algorithmConstraints = params.getAlgorithmConstraints();
        if ((handshaker != null) && !handshaker.started()) {
            handshaker.setIdentificationProtocol(identificationProtocol);
            handshaker.setAlgorithmConstraints(algorithmConstraints);
        }
    }
161078
function Endpoint(spec, resourcePath, method) {
  this.method = method;
  this.resourcePath = resourcePath || '/';
  this.spec = spec;
}
1310767
def dispatch_request(self, *args, **kwargs):
        
        self.args = args
        self.kwargs = kwargs
        self.meth = request.method.lower()
        self.resource = current_app.blueprints.get(request.blueprint, None)

        if not any([self.meth in self.methods, self.meth.upper() in self.methods]):
            return self.return_error(405)

        self.process_before_request_hooks()

        resp = super(Endpoint, self).dispatch_request(*args, **kwargs)
        resp = self.make_response(resp)

        resp = self.process_after_request_hooks(resp)

        return resp
935455
function Dispatcher(req, res, next) {
            _classCallCheck(this, Dispatcher);

            this.req = req;
            this.res = res;
            this.next = next;
         }
1207936
def get_endpoint(endpoint_id)
      endpoint = EndPoint.new(@client.make_request(:get, @client.concat_user_path("#{DOMAIN_PATH}/#{id}/endpoints/#{endpoint_id}"))[0],
                           @client)
      endpoint.domain_id = id
      endpoint
    end
904716
def parse_endpoint_from_params(protocol, azure_vm_name, endpoint_param_string)
      fields = endpoint_param_string.split(":").map(&:strip)
      hash = {}
      hash["LocalPort"] = fields[0]
      hash["Port"] = fields[1] || fields[0]
      hash["LoadBalancerName"] = fields[2] if fields[2] != "EXTERNAL" # TODO: hackity hack.. Shouldn't use magic words.
      hash["LoadBalancedEndpointSetName"] = fields[3]
      hash["Protocol"] = protocol
      if TCP_ENDPOINTS_MAPPING.include?(hash["Port"]) && protocol == "TCP"
        hash["Name"] = TCP_ENDPOINTS_MAPPING[hash["Port"]]
      else
        hash["Name"] = "#{protocol}Endpoint_chef_#{fields[0]}"
      end
      if fields[2]
        hash["LoadBalancerProbe"] = {}
        hash["LoadBalancerProbe"]["Path"] = fields[4]
        hash["LoadBalancerProbe"]["Port"] = fields[0]
        hash["LoadBalancerProbe"]["Protocol"] = fields[4] ? "HTTP" : protocol
      end
      hash
    end
904987
def default_params(h = {})
      raise ArgumentError, 'Default params must be an object which responds to #to_hash' unless h.respond_to?(:to_hash)
      default_options[:default_params] ||= {}
      default_options[:default_params].merge!(h)
    end
467556
def method_missing(method, *args, &block)
      if redis_operation?(method)
        dispatch(method, *args, &block)
      else
        super
      end
    end
1338498
def request_parameters
      Hash[(Tumblr::Client::POST_OPTIONS | [:id, :type]).map {|key|
        [key.to_s, send(key)] if respond_to?(key) && send(key)
      }.compact]
    end
450463
function make_request_from_instance(params) {
        const this_endpoint = this;
        const { preparer } = this_endpoint;
        const headers = Object.assign(
            {},
            this_endpoint.headers,
            params.headers,
            ); // eslint-disable-line indent
        return this_endpoint.constructor.make_request(
            Object.assign({}, params, { headers, preparer }),
            compose_url_from_instance.bind(this_endpoint),
            ); // eslint-disable-line indent
    }
697041
def endpoints(options = {})
      batches = Enumerator.new do |y|
        options = options.merge(platform_application_arn: @arn)
        resp = @client.list_endpoints_by_platform_application(options)
        resp.each_page do |page|
          batch = []
          page.data.endpoints.each do |e|
            batch << PlatformEndpoint.new(
              arn: e.endpoint_arn,
              client: @client
            )
          end
          y.yield(batch)
        end
      end
      PlatformEndpoint::Collection.new(batches)
    end
101151
public void sendEvent(final Map<String, String> params) {
        executor.execute(new Runnable() {
            @Override
            public void run() {
                // put user id
                params.put("cid", userId);
                Multimap queryParams = HashMultimap.create();
                for (Map.Entry<String, String> entry : params.entrySet()) {
                    String key = entry.getKey();
                    String value = entry.getValue();
                    Preconditions.checkNotNull(key, "Custom search param key must not be null.");
                    Preconditions.checkNotNull(value, "Custom search param value must not be null.");
                    queryParams.put(key, value);
                }
                viSearchHttpClient.get(ENDPOINT_SEND_ACTIONS, queryParams);
            }
        });
    }
392244
def to_routes_with_endpoint
			endpoint =
				parts.reduce(result = Flame::Router::Routes.new) do |hash, part|
					hash[part] ||= Flame::Router::Routes.new
				end
			[result, endpoint]
		end
1348194
def index
      @parameters = Parameter.all
  
      respond_to do |format|
        format.html # index.html.erb
        format.json { render json: @parameters }
      end
    end