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)...);
}
infer_handle_from_fun_t<F>
spawn_in_groups(std::initializer_list<group> gs, F fun, Ts&&... xs) {
actor_config cfg;
return spawn_fun_in_groups<Os>(cfg, gs.begin(), gs.end(), fun,
std::forward<Ts>(xs)...);
}
namespace type_traits
{
namespace detail
{
template <class T> struct decay_preserving_cv
{
typedef typename std::remove_reference<T>::type U;
typedef typename std::conditional<std::is_array<U>::value, typename std::remove_extent<U>::type *, typename std::conditional<std::is_function<U>::value, typename std::add_pointer<U>::type, U>::type>::type type;
};
// Support for SFINAE detection of iterator/pointer ranges (Can it dereference? Can it increment?)
// template<class T, typename = void> struct is_rangeable : std::false_type { };
// template<class T> struct is_rangeable<T, decltype(*std::declval<T&>(), ++std::declval<T&>(), void())> : std::true_type { };
// Support for SFINAE detection of containers (does it have begin() and end()?), made considerably more complex by needing MSVC to work.
template <class T> inline auto is_sequence_impl(T &&) -> decltype(*std::begin(std::declval<T>()), *std::end(std::declval<T>()), bool()) { return true; }
inline int is_sequence_impl(...) { return 0; }
template <class T> struct make_sequence_type
{
auto operator()() const -> decltype(std::declval<T>());
};
template <> struct make_sequence_type<void>
{
int operator()() const;
};
}
//! True if type T is a STL compliant sequence (does it have begin() and end()?)
template <class T, typename = decltype(detail::is_sequence_impl(detail::make_sequence_type<T>()()))> struct is_sequence : std::false_type
{
};
template <> struct is_sequence<void> : std::false_type
{
};
template <class T> struct is_sequence<T, bool> : std::true_type
{
typedef decltype(*std::begin(*((typename std::remove_reference<T>::type *) nullptr))) raw_type; //!< The raw type (probably a (const) lvalue ref) returned by *it
typedef typename detail::decay_preserving_cv<raw_type>::type type; //!< The type held by the container, still potentially const if container does not permit write access
};
#if 0
// Disabled until I find the time to get it working
namespace detail
{
template <size_t N> struct Char
{
char foo[N];
};
// Overload only available if a default constructed T has a constexpr-available size()
template <class T, size_t N = static_cast<T *>(nullptr)->size() + 1> constexpr inline Char<N> constexpr_size(const T &) { return Char<N>(); }
template <class T> constexpr inline Char<1> constexpr_size(...) { return Char<1>(); }
}
/*! Returns true if the instance of v has a constexpr size()
/note This is too overly conservative, it does not correctly return true for constexpr input.
*/
template <class T> constexpr inline bool has_constexpr_size(const T &v) { return sizeof(detail::constexpr_size<typename std::decay<T>::type>(std::move(v))) > 1; }
//! \overload
template <class T> constexpr inline bool has_constexpr_size() { return sizeof(detail::constexpr_size<typename std::decay<T>::type>(std::declval<T>())) > 1; }
static_assert(has_constexpr_size<std::array<std::string, 2>>(), "failed");
#if 0
// Non-constexpr array (always has a constexpr size())
auto ca = std::array<int, 2>();
// Constexpr initializer_list (has constexpr size()). Note fails to compile on
// VS2015 as its initializer_list isn't constexpr constructible yet
#ifndef _MSC_VER
constexpr std::initializer_list<int> cil{ 1, 2 };
#endif
// Non-constexpr initializer_list (does not have constexpr size())
std::initializer_list<int> il{ 1, 2 };
// Non-constexpr vector (never has constexpr size())
std::vector<int> vec{ 1, 2 };
// Correct on GCC 4.9 and clang 3.8 and VS2015
static_assert(ca.size(), "non-constexpr array size constexpr");
// Correct on GCC 4.9 and clang 3.8.
#ifndef _MSC_VER
static_assert(cil.size(), "constexpr il size constexpr");
#endif
// Fails as you'd expect everywhere with non-constexpr il error
// static_assert(il.size(), "non-constexpr il size constexpr");
// Correct on GCC 4.9 and clang 3.8 and VS2015
static_assert(has_constexpr_size(ca), "ca");
// Incorrect on GCC 4.9 and clang 3.8 and VS2015
#ifndef _MSC_VER
static_assert(!has_constexpr_size(cil), "cil"); // INCORRECT!
#endif
// Correct on GCC 4.9 and clang 3.8 and VS2015
static_assert(!has_constexpr_size(il), "il");
// Correct on GCC 4.9 and clang 3.8 and VS2015
static_assert(!has_constexpr_size(vec), "vec");
constexpr bool test_ca() {
return has_constexpr_size(std::array<int, 2>{1, 2});
}
constexpr bool testca = test_ca();
// Correct on GCC 4.9 and clang 3.8 and VS2015
static_assert(testca, "testca()");
constexpr bool test_cil() {
return has_constexpr_size(std::initializer_list<int>{1, 2});
}
constexpr bool testcil = test_cil();
// Incorrect on GCC 4.9 and clang 3.8 and VS2015
static_assert(!testcil, "testcil()"); // INCORRECT!
#endif
#endif
}
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());
}
Value Object::callAsFunction(std::initializer_list<JSValueRef> args) const {
return callAsFunction(nullptr, args.size(), args.begin());
}
/// constructor using initializer list
VectorBase(std::initializer_list<value_type> l)
: super(l.size())
{
std::copy(l.begin(), l.end(), _elements);
}
Value Object::callAsFunction(const Object& thisObj, std::initializer_list<JSValueRef> args) const {
return callAsFunction((JSObjectRef)thisObj, args.size(), args.begin());
}
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 });
}
}
constexpr Z(std::initializer_list<int> il) : i_(il.begin()[0]), j_(il.begin()[1])
{throw 6;}
Map(std::initializer_list<std::pair<const Key, Value> > list){
for(auto i = begin(list); list.end(list); ++i){
bst->insert(*i);
}
}
void test_container( std::initializer_list<T>& c )
{
assert ( std::size(c) == c.size());
}
extern bool check_args(RuntimeInfo& runinfo,
const std::vector<Symbol*>& vecSyms,
const std::initializer_list<unsigned int>& lstTypes,
const std::initializer_list<bool> &lstOptional,
const char* pcFkt, const char* pcErr)
{
const std::size_t iSyms = vecSyms.size();
const std::size_t iTypes = lstTypes.size();
const std::size_t iTotalOpt = lstOptional.size();
std::size_t iCompulsory = 0;
for(bool bOpt : lstOptional)
if(!bOpt) ++iCompulsory;
if(iSyms < iCompulsory)
{
std::ostringstream ostrErr;
ostrErr << linenr(runinfo)
<< "Function \"" << pcFkt << "\""
<< " requires " << iCompulsory
<< " arguments, but only "
<< iSyms << " were given.";
if(pcErr) ostrErr << " " << pcErr;
ostrErr << std::endl;
throw tl::Err(ostrErr.str(),0);
}
std::vector<Symbol*>::const_iterator iterSym = vecSyms.begin();
std::initializer_list<unsigned int>::iterator iterTypes = lstTypes.begin();
std::initializer_list<bool>::iterator iterOptional = lstOptional.begin();
std::size_t iCurSym = 0;
for(; iterSym!=vecSyms.end(); ++iterSym, ++iterTypes, ++iterOptional, ++iCurSym)
{
// ignore remaining symbols
if(iCurSym >= iTypes || iCurSym >= iTotalOpt)
break;
if(!*iterSym)
{
std::ostringstream ostrErr;
ostrErr << linenr(runinfo)
<< "Argument " << (iCurSym+1)
<< " of function \"" << pcFkt << "\""
<< " is invalid.";
if(pcErr) ostrErr << " " << pcErr;
ostrErr << std::endl;
throw tl::Err(ostrErr.str(),0);
}
if(!(*iterTypes & (*iterSym)->GetType()))
{
std::ostringstream ostrErr;
ostrErr << linenr(runinfo)
<< "Argument " << (iCurSym+1)
<< " of function \"" << pcFkt << "\""
<< " has wrong type. "
<< "Expected " << get_type_name(*iterTypes)
<< ", received " << get_type_name((*iterSym)->GetType())
<< ".";
if(pcErr) ostrErr << " " << pcErr;
ostrErr << std::endl;
throw tl::Err(ostrErr.str(),0);
}
}
return 1;
}
HALMD_GPU_ENABLED fixed_vector(std::initializer_list<U> const& v,
typename std::enable_if<std::is_convertible<U, double>::value>::type* dummy = 0)
{
assert( v.size() == _Base::size() );
std::copy(v.begin(), v.end(), _Base::begin());
}
void test_container( std::initializer_list<T>& c)
{
assert ( std::data(c) == c.begin());
}