C++ string_ref类代码示例

void Writer::operator() (const string_ref &s) {
  if (need_indent) {
    need_indent = 0;
    write_indent();
  }
  append (s.begin(), s.length());
}

inline size_t find_char(const string_ref& s, char c)
{
  const char *b = s.begin();
  const char *e = s.end();
  const char *const p = memchr_char(b, c, e - b);
  return p ? (p - b) : (e - b);
}

 string_ref next() const {
     const int pos = src_.substr(pos_).find_first_of(sep_);
     const int old_pos = pos_;
     if (pos != -1)
         pos_ += pos + 1;
     else
         finished_ = true;
     return src_.substr(old_pos, pos);
 }

        void id_value(string_ref value)
        {
            if (id_placeholder* p = state.get_placeholder(value))
            {
                assert(!use_resolved_ids ||
                    p->check_state(id_placeholder::generated));
                std::string const& id = use_resolved_ids ?
                    p->id : p->unresolved_id;

                result.append(source_pos, value.begin());
                result.append(id.begin(), id.end());
                source_pos = value.end();
            }
        }

void
consensus::create(
  const string_ref cached_consensus_path,
  bool force_download
  )
{
  string consensus_content;
  bool have_valid_consensus = false;

  //
  // if no path to the cached consensus file
  // was provided, we have to download it.
  //
  if (cached_consensus_path.is_empty() || !io::file::exists(cached_consensus_path))
  {
    force_download = true;
  }

  while (!have_valid_consensus)
  {
    consensus_content = force_download
      ? download_from_random_authority("/tor/status-vote/current/consensus")
      : io::file::read_to_string(cached_consensus_path);

    parse_consensus(consensus_content);

    have_valid_consensus = _valid_until >= time::now();

    //
    // if the consensus is invalid, we have to download it anyway.
    //
    if (!have_valid_consensus)
    {
      force_download = true;
    }
  }

  //
  // save the consensus content, if the path was provided.
  //
  if (force_download && !cached_consensus_path.is_empty())
  {
    io::file::write_from_string(cached_consensus_path, consensus_content);
  }
}

void conn_info::append_escaped(const string_ref& rng, std::string& dst)
{
    for(string_ref::difference_type i=0; i < rng.size(); ++i) {
        if(rng[i]=='\\')
            dst+="\\\\";
        else if(rng[i]=='\'')
            dst+="\\\'";
        else
            dst+=rng[i];
    }
}

int
smtp_client::detail::read_response(buffered_file& conn,
  string_ref& resp_r, posix_error_callback& ec)
{
  ssize_t len = 0;
  char *line = 0;
  while (true) {
    len = conn.read_line_crlf(line, ec);
    if (len <= 0) {
      resp_r.reset();
      break;
    }
    DBG_SMTP(std::cout << "R: " << std::string(line, len));
    if (len <= 5 || line[3] == ' ') {
      resp_r.set(line, len);
      return response_code(line, len);
    }
  }
  return len; /* <= 0 (unexpected eof or error) */
}

string
consensus::download_from_random_authority(
  const string_ref path
  )
{
  net::ip_address ip;
  uint16_t port;

  auto authority = default_authority_list[
    3
    //  mini::crypto::random_device->get_random(default_authority_list.get_size())
  ];

  ip = authority.ip;
  port = authority.dir_port;

  mini_debug(
    "consensus::download_from_random_authority() [path: http://%s:%u%s]",
    ip.to_string().get_buffer(),
    port,
    path.get_buffer());

  return net::http::client::get(ip.to_string(), port, path);
}

 size_t operator()(string_ref const& sr) const {
     return boost::hash_range(sr.begin(), sr.end());
 }

 void finish(string_ref xml)
 {
     result.append(source_pos, xml.end());
     source_pos = xml.end();
 }

 inline void swap(string_ref& x, string_ref& y)
 {
     x.swap(y);
 }

inline bool
operator !=(const string_ref& x, const string_ref& y) {
    return (x.size() != y.size()) ||
           (::memcmp(x.begin(), y.begin(), x.size()) != 0);
}

void
hstcpcli::request_buf_exec_generic(size_t pst_id, const string_ref& op,
  const string_ref *kvs, size_t kvslen, uint32_t limit, uint32_t skip,
  const string_ref& mod_op, const string_ref *mvs, size_t mvslen,
  const hstcpcli_filter *fils, size_t filslen, int invalues_keypart,
  const string_ref *invalues, size_t invalueslen)
{
  if (num_req_sent > 0 || num_req_rcvd > 0) {
    close();
    set_error(-1, "request_buf_exec_generic: protocol out of sync");
    return;
  }
  append_uint32(writebuf, pst_id); // FIXME size_t ?
  writebuf.append_literal("\t");
  writebuf.append(op.begin(), op.end());
  writebuf.append_literal("\t");
  append_uint32(writebuf, kvslen); // FIXME size_t ?
  for (size_t i = 0; i < kvslen; ++i) {
    const string_ref& kv = kvs[i];
    append_delim_value(writebuf, kv.begin(), kv.end());
  }
  if (limit != 0 || skip != 0 || invalues_keypart >= 0 ||
    mod_op.size() != 0 || filslen != 0) {
    /* has more option */
    writebuf.append_literal("\t");
    append_uint32(writebuf, limit); // FIXME size_t ?
    if (skip != 0 || invalues_keypart >= 0 ||
      mod_op.size() != 0 || filslen != 0) {
      writebuf.append_literal("\t");
      append_uint32(writebuf, skip); // FIXME size_t ?
    }
    if (invalues_keypart >= 0) {
      writebuf.append_literal("\[email protected]\t");
      append_uint32(writebuf, invalues_keypart);
      writebuf.append_literal("\t");
      append_uint32(writebuf, invalueslen);
      for (size_t i = 0; i < invalueslen; ++i) {
	const string_ref& s = invalues[i];
	append_delim_value(writebuf, s.begin(), s.end());
      }
    }
    for (size_t i = 0; i < filslen; ++i) {
      const hstcpcli_filter& f = fils[i];
      writebuf.append_literal("\t");
      writebuf.append(f.filter_type.begin(), f.filter_type.end());
      writebuf.append_literal("\t");
      writebuf.append(f.op.begin(), f.op.end());
      writebuf.append_literal("\t");
      append_uint32(writebuf, f.ff_offset);
      append_delim_value(writebuf, f.val.begin(), f.val.end());
    }
    if (mod_op.size() != 0) {
      writebuf.append_literal("\t");
      writebuf.append(mod_op.begin(), mod_op.end());
      for (size_t i = 0; i < mvslen; ++i) {
	const string_ref& mv = mvs[i];
	append_delim_value(writebuf, mv.begin(), mv.end());
      }
    }
  }
  writebuf.append_literal("\n");
  ++num_req_bufd;
}

 string_ref rest() const { return src_.substr(pos_); }

template <size_t N> inline bool
operator ==(const string_ref& x, const char (& y)[N]) {
    return (x.size() == N - 1) && (::memcmp(x.begin(), y, N - 1) == 0);
}