void updateContainer(Cont<T, Alloc>& cont) {
// flip a coin to determine using emplace_back() with 80% of likelihood, or pop_back() with 20% of likelihood.
static std::bernoulli_distribution dist(.8);
if (cont.empty() || dist(S1::s_gen)) {
cont.emplace_back();
} else {
cont.pop_back();
}
// and with 20% likelihood mutating 1st and last elem's std::string field
if (!cont.empty() && !dist(S1::s_gen)) {
cont.front().m_str.append("- foo");
cont.back().m_str.append("- bar");
}
}
iterator insert(value_type&& val) {
if (container.empty()) {
return container.insert(detail::adl_cend(container), val);
}
auto elementgreaterthanorequalto = std::lower_bound(detail::adl_cbegin(container), detail::adl_cend(container), val, std::ref(predicate));
return container.insert(elementgreaterthanorequalto, std::move(val));
}
iterator emplace(Tn&&... argn) {
if (container.empty()) {
return container.insert(detail::adl_cend(container), std::forward<Tn>(argn)...);
}
auto elementgreaterthanorequalto = std::lower_bound(detail::adl_cbegin(container), detail::adl_cend(container), val, std::ref(predicate));
return container.emplace(elementgreaterthanorequalto, std::forward<Tn>(argn)...);
}
iterator emplace(Tn&&... argn) {
if (container.empty()) {
return container.emplace(cend(), std::forward<Tn>(argn)...);
}
auto elementgreaterthanorequalto = std::lower_bound(cbegin(), cend(), val, std::ref(compare_predicate));
return container.emplace(elementgreaterthanorequalto, std::forward<Tn>(argn)...);
}
iterator insert(value_type&& val) {
if (container.empty()) {
return container.insert(cend(), val);
}
auto elementgreaterthanorequalto = std::lower_bound(cbegin(), cend(), val, std::ref(compare_predicate));
return container.insert(elementgreaterthanorequalto, std::move(val));
}
// return shared pointer to value - which if set to nullptr,
// indicates container was empty at the time of the call.
inline std::shared_ptr<T> try_pop() {
std::lock_guard<std::mutex> lock(mut);
if (data_queue.empty()) {
return std::shared_ptr<T>();
} else {
auto res = std::move(front_or_top(data_queue));
data_queue.pop();
return std::move(res);
}
}
// return value in specified reference indicating whether
// value successfully returned or not
inline bool try_pop(std::shared_ptr<T>& rValue) {
std::lock_guard<std::mutex> lock(mut);
if (data_queue.empty()) {
rValue.reset();
return false;
} else {
rValue = std::move(front_or_top(data_queue));
data_queue.pop();
return true;
}
}
// wait for non empty lambda condition before returning shared pointer to value
inline std::shared_ptr<T> wait_and_pop() {
std::unique_lock<std::mutex> lock(mut);
data_cond.wait(lock, [this]{
return !data_queue.empty() || shutdownFlag;
});
if (!shutdownFlag) {
auto res = std::move(front_or_top(data_queue));
data_queue.pop();
return std::move(res);
}
return nullptr;
}
iterator find(K&& k) {
auto e = end();
if (container.empty()) {
return e;
}
auto elementgreaterthanorequalto = std::lower_bound(begin(), e, k, std::ref(compare_predicate));
if (elementgreaterthanorequalto == e) {
return elementgreaterthanorequalto;
}
decltype(auto) elem = *elementgreaterthanorequalto;
if (equality_predicate(std::forward<K>(k), elem)) {
return elementgreaterthanorequalto;
}
return e;
}
bool empty() const {
return elements.empty();
}
inline bool check_empty(const Cont &c)
{
return c.empty() && c.size() == 0 && c.begin() == c.end();
}
bool empty() const { // return whether the stack is empty
return elems.empty();
}
// thread safe method to check if the queue is empty
// note that if it is empty
inline bool empty() const {
std::lock_guard<std::mutex> lock(mut);
return data_queue.empty();
}
