Get a list of the available domains.

 @param custom_headers [Hash{String => String}] A hash of custom headers that
 will be added to the HTTP request.

 @return [Array] operation results.
327762
def get_domains(custom_headers:nil)
      response = get_domains_async(custom_headers:custom_headers).value!
      response.body unless response.nil?
    end
1082124
public Map<String, String> getCustomRequestHeaders() {
        if (customRequestHeaders == null) {
            return null;
        }
        return Collections.unmodifiableMap(customRequestHeaders);
    }
1519
def headers(h = nil)
      if h
        raise ArgumentError, 'Headers must be an object which responds to #to_hash' unless h.respond_to?(:to_hash)
        default_options[:headers] ||= {}
        default_options[:headers].merge!(h.to_hash)
      else
        default_options[:headers] || {}
      end
    end
296177
def get_capabilities(location, custom_headers:nil)
      response = get_capabilities_async(location, custom_headers:custom_headers).value!
      response.body unless response.nil?
    end
385699
def list_subdomains(self, limit=None, offset=None):
        
        return self.manager.list_subdomains(self, limit=limit, offset=offset)
685242
def get_keys(custom_headers:nil)
      response = get_keys_async(custom_headers:custom_headers).value!
      response.body unless response.nil?
    end
26702
def list_built_in_as_lazy(custom_headers:nil)
      response = list_built_in_async(custom_headers:custom_headers).value!
      unless response.nil?
        page = response.body
        page.next_method = Proc.new do |next_page_link|
          list_built_in_next_async(next_page_link, custom_headers:custom_headers)
        end
        page
      end
    end
1112186
function getOperationResponseHeaders(operation) {
    var headers = [];

    if (operation) {
        _.each(operation.responses, function(response, responseCode) {
            // Convert responseCode to a numeric value for sorting ("default" comes last)
            responseCode = parseInt(responseCode) || 999;

            _.each(response.headers, function(header, name) {
                // We only care about headers that have a default value defined
                if (header.default !== undefined) {
                    headers.push({
                        order: responseCode,
                        name: name.toLowerCase(),
                        value: header.default
                    });
                }
            });
        });
    }

    return _.sortBy(headers, 'order');
}
949532
def show_domain(self, domain_id):
        
        json = self.request('/domains/%s' % domain_id, method='GET')
        status = json.get('status')
        if status == 'OK':
            domain_json = json.get('domain')
            domain = Domain.from_json(domain_json)
            return domain
        else:
            message = json.get('message')
            raise DOPException('[%s]: %s' % (status, message))
852328
def get(query_url,
            headers: {})
      HttpRequest.new(HttpMethodEnum::GET,
                      query_url,
                      headers: headers)
    end
1352049
def get_vary_headers(self, request, response):
        

        headers = []
        accessed = False
        try:
            accessed = request.session.accessed
        except AttributeError:
            pass

        if accessed:
            headers.append("Cookie")
        return headers
854117
def lookup_from_headers(cls, headers):
        

        # A single address, set by this server, returned as an Array
        remote_addr = cls.ips_from(headers.get("REMOTE_ADDR"))

        # Could be a CSV list and/or repeated headers that were concatenated.
        forwarded_ips = cls.ips_from(headers.get("HTTP_X_FORWARDED_FOR"))
        client_ips = cls.ips_from(headers.get("HTTP_CLIENT_IP"))

        # We assume these things about the IP headers:
        #
        #   - X-Forwarded-For will be a list of IPs, one per proxy, or blank.
        #       in order: `client,proxy1,proxy2`
        #   - Client-Ip is propagated from the outermost proxy, or is blank
        #   - REMOTE_ADDR will be the IP that made the request to this server
        #
        # X-Forwarded-For and Client-Ip shouldn't be set at the same time, but
        # if they are, use the one in Forwarded
        ips = forwarded_ips + client_ips + remote_addr

        try:
            return ips[0]
        except IndexError:
            return None
81873
def list_skus(custom_headers:nil)
      response = list_skus_async(custom_headers:custom_headers).value!
      response.body unless response.nil?
    end
983575
private static Iterable<HTTPHeader> getHeaders(HTTPResponse resp, String headerName) {
    final String lowercaseHeaderName = headerName.toLowerCase();
    return Iterables.filter(resp.getHeadersUncombined(), new Predicate<HTTPHeader>() {
      @Override public boolean apply(HTTPHeader header) {
        return header.getName().toLowerCase().equals(lowercaseHeaderName);
      }
    });
  }
877265
def get_headers(self, header_name):
		
		header_name = self.normalize_name(header_name)
		if header_name in self.__headers.keys():
			return tuple(self.__headers[header_name])
334415
def get_all_term_lists(custom_headers:nil)
      response = get_all_term_lists_async(custom_headers:custom_headers).value!
      response.body unless response.nil?
    end
1217025
def get_netki_domains(self, fetch=False):
        """"""
        return NetkiDomains(
            self.resource.netki_domains, self.client, populate=fetch)