Lines Matching defs:std
94 using DownstreamKey = std::tuple<
95 std::vector<
96 std::tuple<StringRef, StringRef, StringRef, size_t, size_t, Proto,
103 create_downstream_key(const std::shared_ptr<SharedDownstreamAddr> &shared_addr,
107 auto &addrs = std::get<0>(dkey);
109 auto p = std::begin(addrs);
111 std::get<0>(*p) = a.host;
112 std::get<1>(*p) = a.sni;
113 std::get<2>(*p) = a.group;
114 std::get<3>(*p) = a.fall;
115 std::get<4>(*p) = a.rise;
116 std::get<5>(*p) = a.proto;
117 std::get<6>(*p) = a.port;
118 std::get<7>(*p) = a.weight;
119 std::get<8>(*p) = a.group_weight;
120 std::get<9>(*p) = a.host_unix;
121 std::get<10>(*p) = a.tls;
122 std::get<11>(*p) = a.dns;
123 std::get<12>(*p) = a.upgrade_scheme;
126 std::sort(std::begin(addrs), std::end(addrs));
128 std::get<1>(dkey) = shared_addr->redirect_if_not_tls;
131 std::get<2>(dkey) = affinity.type;
132 std::get<3>(dkey) = affinity.cookie.name;
133 std::get<4>(dkey) = affinity.cookie.path;
134 std::get<5>(dkey) = affinity.cookie.secure;
135 std::get<6>(dkey) = affinity.cookie.stickiness;
137 std::get<7>(dkey) = timeout.read;
138 std::get<8>(dkey) = timeout.write;
139 std::get<9>(dkey) = mruby_file;
140 std::get<10>(dkey) = shared_addr->dnf;
156 const std::shared_ptr<TicketKeys> &ticket_keys,
158 std::shared_ptr<DownstreamConfig> downstreamconf)
181 std::make_unique<ConnectBlocker>(randgen_, loop_, nullptr, nullptr)),
184 std::copy_n(cid_prefix, cid_prefixlen, std::begin(cid_prefix_));
200 session_cache_memcached_dispatcher_ = std::make_unique<MemcachedDispatcher>(
206 replace_downstream_config(std::move(downstreamconf));
211 std::priority_queue<WeightGroupEntry, std::vector<WeightGroupEntry>,
244 std::shared_ptr<DownstreamConfig> downstreamconf) {
261 std::vector<std::shared_ptr<DownstreamAddrGroup>>(groups.size());
263 std::map<DownstreamKey, size_t> addr_groups_indexer;
266 // mruby::create_mruby_context returns std::unique_ptr and we cannot
267 // use std::make_shared.
268 std::map<StringRef, std::shared_ptr<mruby::MRubyContext>> shared_mruby_ctxs;
275 dst = std::make_shared<DownstreamAddrGroup>();
277 ImmutableString{std::begin(src.pattern), std::end(src.pattern)};
279 auto shared_addr = std::make_shared<SharedDownstreamAddr>();
325 if (mruby_ctx_it == std::end(shared_mruby_ctxs)) {
340 if (it == std::end(addr_groups_indexer)) {
344 addr.connect_blocker = std::make_unique<ConnectBlocker>(
354 addr.live_check = std::make_unique<LiveCheck>(loop_, cl_ssl_ctx_, this,
360 addr.dconn_pool = std::make_unique<DownstreamConnectionPool>();
364 util::shuffle(std::begin(shared_addr->addrs),
365 std::end(shared_addr->addrs), randgen_,
366 [](auto i, auto j) { std::swap((*i).seq, (*j).seq); });
369 std::map<StringRef, WeightGroup *> wgs;
372 if (wgs.find(addr.group) == std::end(wgs)) {
378 shared_addr->wgs = std::vector<WeightGroup>(num_wgs);
404 addr_groups_indexer.emplace(std::move(dkey), i);
406 auto &g = *(std::begin(downstream_addr_groups_) + (*it).second);
437 fut_ = std::async(std::launch::async, [this] {
447 std::lock_guard<std::mutex> g(m_);
449 q_.emplace_back(std::move(event));
458 std::lock_guard<std::mutex> g(m_);
470 wev = std::move(q_.front());
583 std::shared_ptr<TicketKeys> Worker::get_ticket_keys() {
585 return std::atomic_load_explicit(&ticket_keys_, std::memory_order_acquire);
587 std::lock_guard<std::mutex> g(ticket_keys_m_);
592 void Worker::set_ticket_keys(std::shared_ptr<TicketKeys> ticket_keys) {
595 std::atomic_store_explicit(&ticket_keys_, std::move(ticket_keys),
596 std::memory_order_release);
598 std::lock_guard<std::mutex> g(ticket_keys_m_);
599 ticket_keys_ = std::move(ticket_keys);
627 std::mt19937 &Worker::get_randgen() { return randgen_; }
644 std::vector<std::shared_ptr<DownstreamAddrGroup>> &
730 quic_listeners_.emplace_back(std::make_unique<QUICListener>(&addr, this));
737 std::array<char, STRERROR_BUFSIZE> errbuf;
771 std::array<char, NI_MAXHOST> host;
1083 std::array<char, NI_MAXHOST> host;
1109 std::array<char, util::max_hostport> hostport_buf;
1111 auto hostport = util::make_http_hostport(std::begin(hostport_buf),
1170 const std::vector<std::shared_ptr<DownstreamAddrGroup>> &groups,
1194 std::copy(std::begin(host) + 1, std::end(host), rev_host_src.base);
1195 std::reverse(rev_host_src.base, ep);
1209 rev_host = StringRef{std::begin(rev_host) + nread, std::end(rev_host)};
1249 const std::vector<std::shared_ptr<DownstreamAddrGroup>> &groups,
1251 if (std::find(std::begin(hostport), std::end(hostport), '/') !=
1252 std::end(hostport)) {
1258 auto fragment = std::find(std::begin(raw_path), std::end(raw_path), '#');
1259 auto query = std::find(std::begin(raw_path), fragment, '?');
1260 auto path = StringRef{std::begin(raw_path), query};
1274 auto p = std::find(std::begin(hostport), std::end(hostport), ']');
1275 if (p == std::end(hostport)) {
1278 if (p + 1 < std::end(hostport) && *(p + 1) != ':') {
1281 host = StringRef{std::begin(hostport), p + 1};
1283 auto p = std::find(std::begin(hostport), std::end(hostport), ':');
1284 if (p == std::begin(hostport)) {
1287 host = StringRef{std::begin(hostport), p};
1290 if (std::find_if(std::begin(host), std::end(host), [](char c) {
1292 }) != std::end(host)) {
1294 auto ep = std::copy(std::begin(host), std::end(host), low_host.base);
1339 auto p = std::copy_n(server_id, SHRPX_QUIC_SERVER_IDLEN, cid_prefix);