Charon/blockchain
1
0
Fork 0
forked from lthn/blockchain
Code Pull requests Activity
blockchain/contrib/epee/include/misc_language.h

582 lines
16 KiB
C++
Raw Blame History

// Copyright (c) 2019, anonimal, <anonimal@zano.org>
// Copyright (c) 2006-2013, Andrey N. Sabelnikov, www.sabelnikov.net
// All rights reserved.
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are met:
// * Redistributions of source code must retain the above copyright
// notice, this list of conditions and the following disclaimer.
// * Redistributions in binary form must reproduce the above copyright
// notice, this list of conditions and the following disclaimer in the
// documentation and/or other materials provided with the distribution.
// * Neither the name of the Andrey N. Sabelnikov nor the
// names of its contributors may be used to endorse or promote products
// derived from this software without specific prior written permission.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
// ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
// WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
// DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER BE LIABLE FOR ANY
// DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
// (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
// LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
// ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
// SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
//
#pragma once
#include <limits>
#include <set>
#include <iterator>
#include <algorithm>
#include <functional>
#include <boost/thread.hpp>
#include <boost/any.hpp>
#include "include_base_utils.h"
#include "auto_val_init.h"
#define MARK_AS_POD_C11(type) \
namespace std \
{ \
template<> \
struct is_pod< type > \
{ \
static const bool value = true; \
}; \
}
namespace epee
{
#define STD_TRY_BEGIN() try {
#define STD_TRY_CATCH(where_, ret_val) \
} \
catch (const std::exception &e) \
{ \
LOG_ERROR("EXCEPTION: " << where_ << ", mes: "<< e.what()); \
return ret_val; \
} \
catch (...) \
{ \
LOG_ERROR("EXCEPTION: " << where_ ); \
return ret_val; \
}
#define STD_TRY_CATCH_LOCATION(return_val) STD_TRY_CATCH(LOCATION_SS, return_val)
/* helper class, to make able get namespace via decltype()::*/
template<class base_class>
class namespace_accessor: public base_class{};
#define STRINGIFY_EXPAND(s) STRINGIFY(s)
#define STRINGIFY(s) #s
namespace misc_utils
{
template<class _Ty1,
class _Ty2,
class _Ty3>
struct triple
{ // store a pair of values
typedef _Ty1 first_type;
typedef _Ty2 second_type;
typedef _Ty3 third_type;
triple()
: first(), second(), third()
{ // default construct
}
triple(const _Ty1& _Val1, const _Ty2& _Val2, const _Ty3& _Val3)
: first(_Val1), second(_Val2), third(_Val3)
{ // construct from specified values
}
_Ty1 first; // the first stored value
_Ty2 second; // the second stored value
_Ty3 third; // the second stored value
};
template<typename t_type>
t_type get_max_t_val(t_type t)
{
return (std::numeric_limits<t_type>::max)();
}
template<class _Ty>
bool is_less_as_pod(const _Ty& _Left, const _Ty& _Right)
{ // apply operator< to operands
return memcmp(&_Left, &_Right, sizeof(_Left)) < 0;
}
inline
bool sleep_no_w(long ms )
{
boost::this_thread::sleep(
boost::get_system_time() +
boost::posix_time::milliseconds( std::max<long>(ms,0) ) );
return true;
}
/************************************************************************/
/* */
/************************************************************************/
template<typename key, typename associated_data>
class median_helper
{
typedef std::multiset<key> ordered_items_container;
typedef std::pair<typename ordered_items_container::iterator, associated_data> queued_item_type;
typedef std::list<queued_item_type> queued_items_container;
typedef std::list<std::pair<key, associated_data> > recent_items_container;
ordered_items_container ordered_items;
queued_items_container queued_items;
recent_items_container recent_items; // this needed to have chance to roll back at least for some depth, so we keep elements removed from median window for a while
bool had_been_in_recent_items;
mutable critical_section m_lock;
typename ordered_items_container::iterator m_current_median_it;
uint64_t current_index;
virtual void handle_purge_back_item() {}
virtual void handle_add_front_item(const key& k, const associated_data& ad) {}
virtual void handle_remove_front_item(const key& k) {}
void push_item_as_recent(const key& k, const associated_data& ad)
{
CRITICAL_REGION_LOCAL(m_lock);
auto it = ordered_items.insert(k);
queued_items.push_front(queued_item_type(it, ad));
}
public:
median_helper() :had_been_in_recent_items(false)
{
m_current_median_it = ordered_items.end();
current_index = 0;
}
void clear()
{
CRITICAL_REGION_LOCAL(m_lock);
ordered_items.clear();
queued_items.clear();
recent_items.clear();
had_been_in_recent_items = false;
m_current_median_it = ordered_items.end();
current_index = 0;
}
void push_item(const key& k, const associated_data& ad)
{
CRITICAL_REGION_LOCAL(m_lock);
auto it = ordered_items.insert(k);
queued_items.push_back(queued_item_type(it, ad));
handle_add_front_item(k, ad);
}
void pop_item()
{
CRITICAL_REGION_LOCAL(m_lock);
if (!queued_items.empty())
{
auto it = queued_items.back().first;
handle_remove_front_item(*it);
ordered_items.erase(it);
queued_items.pop_back();
}
}
/*
cb(key, associated_data) - enumerating while result is false
when returned true - clean items behind and move it to recent_items
cb_final_remove(key, associated_data) - for every element in recent_items if returned false - element removed forever
*/
template<class cb_t, class cb_t2>
bool scan_items(cb_t cb, cb_t2 cb_final_remove)
{
CRITICAL_REGION_LOCAL(m_lock);
//process median window items
for (auto it = queued_items.begin(); it != queued_items.end(); it++)
{
if (cb(*it->first, it->second))
{
//stop element, remove all items before this
for (auto clean_it = queued_items.begin(); clean_it != it; clean_it++)
{
//std::pair<key, associated_data> p(*it->first, it->second);
recent_items.push_back(std::make_pair(*clean_it->first, clean_it->second));
had_been_in_recent_items = true;
ordered_items.erase(clean_it->first);
}
queued_items.erase(queued_items.begin(), it);
break;
}
}
//process recent items front part (put back to median window set if needed)
for (auto it = recent_items.rbegin(); it != recent_items.rend();)
{
if (!cb(it->first, it->second))
break;//element should stay in recent
//element should be back to median window
this->push_item_as_recent(it->first, it->second);
it = typename recent_items_container::reverse_iterator(recent_items.erase((++it).base())); // remove *it and advance 'it' by 1
}
//process recent items back part (remove outdated elements)
while (recent_items.size() && !cb_final_remove(recent_items.begin()->first, recent_items.begin()->second))
{
recent_items.erase(recent_items.begin());
handle_purge_back_item();
}
//detect if recent_items exhausted
if (!recent_items.size() && had_been_in_recent_items)
{
LOG_PRINT_RED_L0("[MEDIAN_HELPER]: recent_items exhausted, need to rebuild median from scratch");
return false;
}
return true;
}
uint64_t get_median() const
{
CRITICAL_REGION_LOCAL(m_lock);
if (!ordered_items.size())
return 0;
size_t n = ordered_items.size() / 2;
//std::sort(v.begin(), v.end());
auto n_it = std::next(ordered_items.begin(), n);
//nth_element(v.begin(), v.begin()+n-1, v.end());
if (ordered_items.size() % 2)
{//1, 3, 5...
return *n_it;
}
else
{//2, 4, 6...
auto n_it_sub = n_it;
--n_it_sub;
return (*n_it_sub + *n_it) / 2;
}
}
uint64_t get_avg() const
{
CRITICAL_REGION_LOCAL(m_lock);
if (!queued_items.size())
return 0;
uint64_t summ = 0;
for (const auto& item : queued_items)
{
summ += *item.first;
}
return summ / queued_items.size();
}
template<typename key_t, typename associated_data_t>
friend std::ostream & operator<< (std::ostream &out, median_helper<key_t, associated_data_t> const &mh);
}; // class median_helper
template<typename key_t, typename associated_data_t>
std::ostream & operator<< (std::ostream &s, median_helper<key_t, associated_data_t> const &mh)
{
s << "median_helper<" << typeid(key_t).name() << ", " << typeid(associated_data_t).name() << "> instance 0x" << &mh << ENDL
<< " ordered_items: " << mh.ordered_items.size() << ENDL
<< " queued_items: " << mh.queued_items.size() << ENDL
<< " recent_items: " << mh.recent_items.size() << ENDL
<< " had_been_in_recent_items: " << mh.had_been_in_recent_items << ENDL;
return s;
}
/************************************************************************/
/* */
/************************************************************************/
template<typename container_t>
typename container_t::value_type median(container_t &v)
{
typename container_t::value_type median{};
if(v.empty())
return median;
if(v.size() == 1)
return v[0];
auto median_it = v.begin() + v.size() / 2;
std::nth_element(v.begin(), median_it, v.end());
median = *median_it;
if (v.size() % 2 == 0)
{
auto max_it = std::max_element(v.begin(), median_it); // it's garanteed that after nth_element() the necessary element is in this interval
median = (median + *max_it) / 2; // average of [size/2-1] and [size/2] elements
}
return median;
}
/************************************************************************/
/* */
/************************************************************************/
struct call_befor_die_base
{
virtual ~call_befor_die_base(){}
};
typedef boost::shared_ptr<call_befor_die_base> auto_scope_leave_caller;
template<class t_scope_leave_handler>
struct call_befor_die: public call_befor_die_base
{
t_scope_leave_handler m_func;
call_befor_die(t_scope_leave_handler f):m_func(f)
{}
~call_befor_die()
{
NESTED_TRY_ENTRY();
m_func();
NESTED_CATCH_ENTRY(__func__);
}
};
template<class t_scope_leave_handler>
auto_scope_leave_caller create_scope_leave_handler(t_scope_leave_handler f)
{
auto_scope_leave_caller slc(new call_befor_die<t_scope_leave_handler>(f));
return slc;
}
#define ON_EXIT misc_utils::auto_scope_leave_caller scope_exit_handler = misc_utils::create_scope_leave_handler
template< typename t_contaner, typename t_redicate>
void erase_if( t_contaner& items, const t_redicate& predicate )
{
for(auto it = items.begin(); it != items.end(); )
{
if( predicate(*it) )
it = items.erase(it);
else
++it;
}
};
/************************************************************************/
/* */
/************************************************************************/
struct call_basic
{
virtual void do_call(){};
};
template<typename param_t>
struct call_basic_param
{
virtual void do_call(param_t& p) {};
};
template<typename t_callback>
struct call_specific: public call_basic
{
call_specific(t_callback cb):m_cb(cb)
{}
virtual void do_call()
{
m_cb();
}
private:
t_callback m_cb;
};
template<typename param_t, typename t_callback>
struct call_specific_param : public call_basic_param<param_t>
{
call_specific_param(t_callback cb) :m_cb(cb)
{}
virtual void do_call(const param_t& p)
{
m_cb(p);
}
private:
t_callback m_cb;
};
template<typename t_callback>
auto build_abstract_callback(t_callback cb) -> std::shared_ptr<call_basic>
{
return std::shared_ptr<call_basic>(new call_specific<t_callback>(cb));
}
template<typename param_t, typename t_callback>
auto build_abstract_callback_param(t_callback cb) -> std::shared_ptr<call_basic_param<param_t>>
{
return std::shared_ptr<call_basic_param<param_t>>(new call_specific_param<param_t, t_callback>(cb));
}
template<class callback_type>
bool static_initializer(callback_type cb)
{
return cb();
};
template<class t_container_type>
typename t_container_type::mapped_type& get_or_insert_value_initialized(t_container_type& container, const typename t_container_type::key_type& key)
{
auto it = container.find(key);
if (it != container.end())
{
return it->second;
}
auto res = container.insert(typename t_container_type::value_type(key, AUTO_VAL_INIT(typename t_container_type::mapped_type())));
return res.first->second;
}
template<class t_container_type>
typename t_container_type::iterator it_get_or_insert_value_initialized(t_container_type& container, const typename t_container_type::key_type& key)
{
auto it = container.find(key);
if (it != container.end())
{
return it;
}
auto res = container.insert(typename t_container_type::value_type(key, AUTO_VAL_INIT(typename t_container_type::mapped_type())));
return res.first;
}
class events_dispatcher
{
public:
template<typename param_t>
struct callback_entry
{
std::shared_ptr<epee::misc_utils::call_basic_param<const param_t> > m_cb;
};
std::map<std::type_index, boost::any> m_callbacks;
template<typename param_t, typename callback_t>
void SUBSCIRBE_DEBUG_EVENT(callback_t cb)
{
std::type_index ti = typeid(param_t);
auto it = m_callbacks.find(ti);
if (it != m_callbacks.end())
{
throw std::runtime_error("Handler for this type already registered");
}
callback_entry<const param_t> cb_entry = { epee::misc_utils::build_abstract_callback_param<const param_t>(cb) };
m_callbacks[ti] = cb_entry;
}
template<typename param_t>
void UNSUBSCRIBE_DEBUG_EVENT()
{
std::type_index ti = typeid(param_t);
auto it = m_callbacks.find(ti);
if (it != m_callbacks.end())
{
m_callbacks.erase(it);
}
}
void UNSUBSCRIBE_ALL()
{
m_callbacks.clear();
}
template<typename param_t>
void RAISE_DEBUG_EVENT(const param_t& p)
{
std::type_index ti = typeid(param_t);
auto it = m_callbacks.find(ti);
if (it != m_callbacks.end())
{
callback_entry<const param_t >* pcallback_entry = boost::any_cast<callback_entry<const param_t >>(&it->second);
if (!pcallback_entry)
{
throw std::runtime_error("Unexpected error: registered tipe holding something else in boost::eny");
}
pcallback_entry->m_cb->do_call(p);
}
}
};
} // namespace misc_utils
} // namespace epee
template<typename T>
std::ostream& print_container_content(std::ostream& out, const T& v);
namespace std
{
template<typename T>
std::ostream& operator<< (std::ostream& out, const std::vector<T>& v)
{
return print_container_content(out, v);
}
template<typename T>
std::ostream& operator<< (std::ostream& out, const std::list<T>& v)
{
return print_container_content(out, v);
}
} // namespace std
template<typename T>
std::ostream& print_container_content(std::ostream& out, const T& v)
{
out << "[";
if (!v.size())
{
out << "]";
return out;
}
typename T::const_iterator last_it = --v.end();
for (typename T::const_iterator it = v.begin(); it != v.end(); it++)
{
out << *it;
if (it != last_it)
out << ", ";
}
out << "]";
return out;
}
View git blame Copy permalink