Emits the list of SampledRequets with a header.
326600
private static void emitSpans(PrintWriter out, Formatter formatter, Collection<SpanData> spans) {
    out.write("<pre>\n");
    formatter.format("%-23s %18s%n", "When", "Elapsed(s)");
    out.write("-------------------------------------------\n");
    for (SpanData span : spans) {
      tracer
          .getCurrentSpan()
          .addAnnotation(
              "Render span.",
              ImmutableMap.<String, AttributeValue>builder()
                  .put(
                      "SpanId",
                      AttributeValue.stringAttributeValue(
                          BaseEncoding.base16()
                              .lowerCase()
                              .encode(span.getContext().getSpanId().getBytes())))
                  .build());

      emitSingleSpan(formatter, span);
    }
    out.write("</pre>\n");
  }
673555
def header(self, array):
        

        self._check_row_size(array)
        self._header = list(map(obj2unicode, array))
        return self
169644
void print_list() {
	for (int i = 0; i < works.size(); i++) {
	    final WorkItem item = (WorkItem) works.elementAt(i);
	    Util.out4.println("Dev name = " + item.dev.get_name() + ", obj name = " + item.name
		    + ", next wake_up at " + item.wake_up_date.tv_sec + ","
		    + item.wake_up_date.tv_usec);
	}
    }
909546
private void respondToListIdentifiers(Map<String, String> args,
                                          String baseURL,
                                          List<?> headers,
                                          ResumptionToken resumptionToken,
                                          PrintWriter out) {
        appendTop(out);
        appendRequest(args, baseURL, out);
        out.println("  <ListIdentifiers>");
        for (int i = 0; i < headers.size(); i++) {
            Header header = (Header) headers.get(i);
            appendHeader("    ", header, out);
        }
        appendResumptionToken(resumptionToken, out);
        out.println("  </ListIdentifiers>");
        appendBottom(out);
    }
1108311
def emit(self, record):
        """"""
        self.entries.append(self.format(record))
        if len(self.entries) > self.flush_limit and not self.session.auth.renewing:
            self.log_to_api()
            self.entries = []
1043702
private static void emitSingleCell(
      PrintWriter out,
      Formatter formatter,
      String spanName,
      int numSamples,
      RequestType type,
      int subtype)
      throws UnsupportedEncodingException {
    if (numSamples > 0) {
      formatter.format(
          "<td class=\"center\"><a href='?%s=%s&%s=%d&%s=%d'>%d</a></td>%n",
          HEADER_SPAN_NAME,
          URLEncoder.encode(spanName, "UTF-8"),
          HEADER_SAMPLES_TYPE,
          type.getValue(),
          HEADER_SAMPLES_SUB_TYPE,
          subtype,
          numSamples);
    } else if (numSamples < 0) {
      out.write("<td class=\"center\">N/A</td>\n");
    } else {
      out.write("<td class=\"center\">0</td>\n");
    }
  }
177121
def headerlist(self):
        
        if 'Content-Type' not in self.headers:
            self.headers.add_header('Content-Type', self.default_content_type)
        if self._cookies:
            for c in self._cookies.values():
                self.headers.add_header('Set-Cookie', c.OutputString())
        return self.headers.items()
156202
static List<HpackHeader> createHeaders(int numHeaders, int nameLength, int valueLength,
                                           boolean limitToAscii) {
        List<HpackHeader> hpackHeaders = new ArrayList<HpackHeader>(numHeaders);
        for (int i = 0; i < numHeaders; ++i) {
            byte[] name = randomBytes(new byte[nameLength], limitToAscii);
            byte[] value = randomBytes(new byte[valueLength], limitToAscii);
            hpackHeaders.add(new HpackHeader(name, value));
        }
        return hpackHeaders;
    }
1257222
private void setHeaderList(Map<String, List<String>> headers, String name, String value) {

        List<String> values = new ArrayList<String>();
        values.add(SET_HEADER + value);
        headers.put(name, values);
    }
1303349
def build_header_output
      output = []

      @header.each do |line|
        _data = []
        line.each do |h|
          _data << {:value => h, :color => @style[:header]}
        end
        output << _data
      end
      output
    end
367543
def process_header(self, headers):
        """"""

        return [c.name for c in self.source.dest_table.columns][1:]
597177
def header(self, array):
        

        self._check_row_size(array)
        self._header = map(str, array)
405972
public T headers(Map<String, Object> headers) {
        getMessageContentBuilder().getMessageHeaders().putAll(headers);
        return self;
    }
58715
def emit(self, signal, *args):
        
        callbacks = self._callbacks.get(signal, [])
        new_callbacks = []
        for callback in callbacks:
            # clear out deleted pointers
            if not callback.isValid():
                continue

            new_callbacks.append(callback)

            try:
                callback(*args)
            except StandardError:
                logger.exception('Error occurred during callback.')

        self._callbacks[signal] = new_callbacks
243763
public static void processHeaders(Map<String, List<String>> headers, HttpServletResponse res) {

        if (headers != null) {
            Iterator<Map.Entry<String, List<String>>> i = headers.entrySet().iterator();
            while (i.hasNext()) {
                Map.Entry<String, List<String>> entry = i.next();
                String key = entry.getKey();
                List<String> l = entry.getValue();
                for (int j = 0; j < l.size(); j++) {
                    if ((j == 0) && ((l.get(0)).startsWith(SET_HEADER))) {
                        String s = l.get(0);
                        res.setHeader(key, s.substring(SET_HEADER.length()));
                    } else {
                        res.addHeader(key, l.get(j));
                    }
                }
            }
        }
    }
101028
private void setHeadersComplete() {
        if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) {
            Tr.debug(tc, "completed headers have been received stream " + myID);
        }
        headersCompleted = true;
        muxLink.setContinuationExpected(false);
    }
966477
private Map<String, String> prepareHeaderRowDataMap(List<String> header, List<String> rowData) {
        Map<String, String> headerRowDataMap = new HashMap<>();
        if (header.size() == rowData.size()) {
            for (int i = 0; i < header.size(); i++) {
                if (null != header.get(i)) {
                    headerRowDataMap.put(header.get(i).toLowerCase(), rowData.get(i));
                }
            }
        } else {
            logger.warning("header and columns are not of same size");
        }
        return headerRowDataMap;
    }