Given a dictionary of values and (optionally) a header for a file,
    join with another file with a linear pass that does not store The
    file's values

    :param d_vals: dictionary of key-value pairs to match up with the lines
                   in the second file. If header_f1 is None, the values should
                   be ordered iterables --output will be in presentation order.
                   If f1_header is not None, values should be dictionary-like
                   objects accessible via a keys --output will be in the order
                   that the keys appear in header_f1
    :param s_f_strm: TODO
    :param s_f_key: TODO
    :param header: TODO
    :param f2_has_header: TODO
    :param missing_val: TODO
    :param verbose: TODO

def process_without_storing(d_vals, s_f_strm, s_f_key, output_type, outfh,
                            f_f_header=None, s_f_has_header=False,
                            missing_val=None, delim=None,
                            ignore_missing_keys=False,
                            output_unpaired=False, verbose=False):
  """
    Given a dictionary of values and (optionally) a header for a file,
    join with another file with a linear pass that does not store The
    file's values

    :param d_vals: dictionary of key-value pairs to match up with the lines
                   in the second file. If header_f1 is None, the values should
                   be ordered iterables --output will be in presentation order.
                   If f1_header is not None, values should be dictionary-like
                   objects accessible via a keys --output will be in the order
                   that the keys appear in header_f1
    :param s_f_strm: TODO
    :param s_f_key: TODO
    :param header: TODO
    :param f2_has_header: TODO
    :param missing_val: TODO
    :param verbose: TODO
  """
  used_d_val_keys = set()
  key_field_num = s_f_key
  s_f_header = None
  seen_keys = set()
  out_handler = output_type.get_handler()
  expected_cols_per_line = None
  first_element = True
  for line in file_iterator(s_f_strm, verbose):
    parts = __populated_missing_vals(line.split(delim), missing_val)

    # on the first element, we might have to output a header..
    if first_element:
      regular_first, s_f_header, key_field_num =\
          process_without_storing_header(parts, d_vals, f_f_header,
                                         s_f_has_header, s_f_header, s_f_key,
                                         key_field_num, out_handler, outfh,
                                         missing_val, delim)

    # any line that is either not the first, or is the first but we decided
    # it wasn't a header line...
    if not first_element or regular_first:
      if expected_cols_per_line is None:
        expected_cols_per_line = (len(parts) if s_f_header is None
                                  else len(s_f_header))
      if expected_cols_per_line != len(parts):
        raise RaggedInputError("Found line with " + str(len(parts)) + " "
                               "columns, but was expecting " +
                               str(expected_cols_per_line) + " columns")

      key_val = get_key_value(parts, key_field_num, ignore_missing_keys,
                              seen_keys, output_type)
      if key_val is None and ignore_missing_keys:
        continue
      seen_keys.add(key_val)

      if key_val not in d_vals:
        if not output_unpaired:
          continue
        f_f_flds = populate_unpaired_line(d_vals, f_f_header, missing_val)
      else:
        f_f_flds = d_vals[key_val]
        used_d_val_keys.add(key_val)
      s_f_flds = ([dict(zip(s_f_header, parts))]
                  if s_f_header is not None else [parts])
      out_handler.write_output(outfh, delim, s_f_flds, f_f_flds,
                               s_f_header, f_f_header)
    first_element = False

  if output_unpaired:
    __output_unpaired_vals(d_vals, used_d_val_keys, f_f_header, s_f_flds,
                           s_f_header, missing_val, out_handler, outfh, delim)