bool any_of(const std::string& key, std::initializer_list<T> list) const {
     std::unordered_map<std::string, double>::const_iterator it = _opt.find(key);
     return (it != _opt.cend() && std::any_of(list.begin(), list.end(), [&](const T& t) { return t == static_cast<T>(it->second); }));
 }

AppInitializer::AppInitializer(std::initializer_list<int> subsystem_flags) {
	for (auto it = subsystem_flags.begin(); it != subsystem_flags.end(); it++) {
		initializeSystem(*it);
	}
}

 //! Requires: il.size() == Rank.
 //! Effects: For all i in the range [0, Rank), initializes the ith
 //! component of *this with *(il.begin() + i).
 index(std::initializer_list<value_type> const& il)
 {
     HPX_ASSERT(il.size() == std::size_t(rank) &&
         "il.size() must be equal to Rank");
     std::copy(il.begin(), il.end(), vs_ + 0);
 }

			vec3(std::initializer_list<float> ilist) { auto* p = ilist.begin();  x = *p++; y = *p++; z = *p++; }

 bool in(const std::initializer_list<T1>& s, const T2& x) {
     return std::find(s.begin(), s.end(), x) != s.end();
 }

 binary(std::initializer_list<uint8_t> bytes, const Alloc& alloc = Alloc())
     : binary(reinterpret_cast<const char*>(bytes.begin()), bytes.size(), alloc) {}

 void init(const std::initializer_list<int>& il) {
   vect.resize(il.size());
   std::move_backward(il.begin(), il.end(), vect.end());
 }

void KeyMultiValueTagFilter::setValues(std::initializer_list<std::string> l)
{
	setValues(l.begin(), l.end());
}

//MultiKeyTagFilter
MultiKeyTagFilter::MultiKeyTagFilter(std::initializer_list< std::string > l) :
m_KeySet(l.begin(), l.end())
{}

 pointer_vector(std::initializer_list<T> list) : pool(0), poolsize(0), objectsize(0) {
   for(const T *p = list.begin(); p != list.end(); ++p) append(*p);
 }

	/*! \brief Constructor from a list of numbers
	 *
	 * \param c list of numbers
	 *
	 */
	comb(std::initializer_list<char> c)
	{
		size_t i = 0;
	    for(char x : c)
	    {this->c[c.size() - i - 1] = x;i++;}
	}

LinkedList<T>::LinkedList(std::initializer_list<T> elements)
{
	head->data = elements.begin()[0];
}

 infer_handle_from_class_t<T>
 spawn_in_groups(std::initializer_list<group> gs, Ts&&... xs) {
   actor_config cfg;
   return spawn_class_in_groups<T, Os>(cfg, gs.begin(), gs.end(),
                                       std::forward<Ts>(xs)...);
 }

void MultiKeyTagFilter::addValues(std::initializer_list<std::string> l)
{
	addValues(l.begin(), l.end());
}

VertexDescription::VertexDescription(std::initializer_list<VertexDescriptionElement> elements) {
  m_elements.resize(elements.size());
  std::copy(elements.begin(), elements.end(), m_elements.begin());
}

 /// constructor using initializer list
 VectorBase(std::initializer_list<value_type> l) 
   : super(l.size())
 {
   std::copy(l.begin(), l.end(), _elements);
 }

					local(std::initializer_list<int> ilist)
					{
						payload1 = ilist.begin()[0];
						payload2 = ilist.begin()[1];
					}

node::node( op_id o, const dimensions &d, std::initializer_list<node_id> inputs, any val, hash::value hv )
	: _hash( std::move( hv ) ), _dims( d ), _value( std::move( val ) ), _op_id( o )
{
	resize_edges( static_cast<uint32_t>( inputs.size() ), 0 );
	std::copy( inputs.begin(), inputs.end(), _edges );
}

 strict_lock(std::initializer_list<thread_detail::lockable_wrapper<Lockable> > l_) :
   mtx_(*(const_cast<thread_detail::lockable_wrapper<Lockable>*>(l_.begin())->m))
 {
   mtx_.lock();
 }

	Response BaseDiscordClient::request(const RequestMethod method, Route path, const std::string jsonParameters/*,
		cpr::Parameters httpParameters*/, const std::initializer_list<Part>& multipartParameters) {
		//check if rate limited
		Response response;
		const time_t currentTime = getEpochTimeMillisecond();
		if (isGlobalRateLimited) {
			if (nextRetry <= currentTime) {
				isGlobalRateLimited = false;
			} else {
				onExceededRateLimit(isGlobalRateLimited, nextRetry - currentTime, { *this, method, path, jsonParameters, multipartParameters });
				response.statusCode = TOO_MANY_REQUESTS;
				setError(response.statusCode);
				return response;
			}
		}
		const std::string bucket = path.bucket(method);
		auto bucketResetTimestamp = buckets.find(bucket);
		if (bucketResetTimestamp != buckets.end()) {
			if (bucketResetTimestamp->second <= currentTime) {
				buckets.erase(bucketResetTimestamp);
			} else {
				onExceededRateLimit(false, bucketResetTimestamp->second - currentTime, { *this, method, path, jsonParameters, multipartParameters });
				response.statusCode = TOO_MANY_REQUESTS;
				setError(response.statusCode);
				return response;
			}
		}
		{	//the { is used so that onResponse is called after session is removed to make debugging performance issues easier
			//request starts here
			Session session;
			session.setUrl("https://discordapp.com/api/v6/" + path.url());
			std::vector<HeaderPair> header = {
				{ "Authorization", bot ? "Bot " + getToken() : getToken() },
				{ "User-Agent", "DiscordBot (https://github.com/yourWaifu/SleepyDiscord, vtheBestVersion)" },
			};
			if (jsonParameters != "") {
				session.setBody(&jsonParameters);
				header.push_back({ "Content-Type"  , "application/json"                      });
				header.push_back({ "Content-Length", std::to_string(jsonParameters.length()) });
			//} else if (httpParameters.content != "") {	//this is broken for now
			//	session.SetParameters(httpParameters);
			} else if (0 < multipartParameters.size()) {
				session.setMultipart(multipartParameters);
				header.push_back({ "Content-Type", "multipart/form-data" });
			} else {
				header.push_back({ "Content-Length", "0" });
			}
			session.setHeader(header);
			//Response response;
			switch (method) {
			case Post:   response = session.Post();   break;
			case Patch:  response = session.Patch();  break;
			case Delete: response = session.Delete(); break;
			case Get:    response = session.Get();    break;
			case Put:    response = session.Put();    break;
			default:     response.statusCode = BAD_REQUEST; break; //unexpected method
			}
			//status checking
			switch (response.statusCode) {
			case OK: case CREATED: case NO_CONTENT: case NOT_MODIFIED: break;
			case TOO_MANY_REQUESTS: {   //this should fall down to default
				int retryAfter = std::stoi(response.header["Retry-After"]);
				isGlobalRateLimited = response.header["X-RateLimit-Global"] == "true";
				nextRetry = getEpochTimeMillisecond() + retryAfter;
				if (!isGlobalRateLimited)
					buckets[bucket] = nextRetry;
				onExceededRateLimit(isGlobalRateLimited, retryAfter, { *this, method, path, jsonParameters, multipartParameters });
			}
			default:
			{		//error
				const ErrorCode code = static_cast<ErrorCode>(response.statusCode);
				setError(code);		//https error
				std::vector<std::string> values = json::getValues(response.text.c_str(),
				{ "code", "message" });	//parse json to get code and message
				if (!values.empty() && values[0] != "")
					onError(static_cast<ErrorCode>(std::stoi(values[0])), values[1]);	//send message to the error event
				else
					onError(ERROR_NOTE, response.text);
#if defined(__cpp_exceptions) || defined(__EXCEPTIONS)
				throw code;
#endif
			} break;
			}
			//rate limit check
			if (response.header["X-RateLimit-Remaining"] == "0" && response.statusCode != TOO_MANY_REQUESTS) {
				std::tm date = {};
				//for some reason std::get_time requires gcc 5
				std::istringstream dateStream(response.header["Date"]);
				dateStream >> std::get_time(&date, "%a, %d %b %Y %H:%M:%S GMT");
				const time_t reset = std::stoi(response.header["X-RateLimit-Reset"]);
#if defined(_WIN32) || defined(_WIN64)
				std::tm gmTM;
				std::tm*const resetGM = &gmTM;
				gmtime_s(resetGM, &reset);
#else
				std::tm* resetGM = std::gmtime(&reset);
#endif
				const time_t resetDelta = (std::mktime(resetGM) - std::mktime(&date)) * 1000;
				buckets[bucket] = resetDelta + getEpochTimeMillisecond();
				onDepletedRequestSupply(resetDelta, { *this, method, path, jsonParameters, multipartParameters });
//.........这里部分代码省略.........