gen_utils.h

#pragma once
 
#ifndef gen_utils_h
#define gen_utils_h
 
#include <boost/lexical_cast.hpp>
#include <boost/uuid/uuid.hpp>
#include <boost/uuid/uuid_generators.hpp>
#include <boost/uuid/uuid_io.hpp>
#include <boost/property_tree/ptree.hpp>
#include <boost/property_tree/json_parser.hpp>
#include "rapidjson/document.h"
#include <boost/thread/recursive_mutex.hpp>
#include <boost/thread/thread.hpp>
#include <boost/thread/condition_variable.hpp>
#include <chrono>
#include <thread>
#include <atomic>
#include "include_base_utils.h"
#include "common/util.h"

namespace gen_utils
{

  static std::string get_uuid() {
    boost::uuids::random_generator generator;
    boost::uuids::uuid uuid = generator();
    return boost::uuids::to_string(uuid);
  }

  static void wait_for(uint64_t duration_ms) {
    std::this_thread::sleep_for(std::chrono::milliseconds(duration_ms));
  }
 
  static bool bool_equals(bool val, const boost::optional<bool>& opt_val) {
    return opt_val == boost::none ? false : val == *opt_val;
  }
 
  // ------------------------- SERIALIZATION ---------------------------
 
  // TODO: fully switch from property trees to rapidjson
 
  std::string serialize(const rapidjson::Document& doc);
  std::string serialize(const boost::property_tree::ptree& node);
  void deserialize(const std::string& json, boost::property_tree::ptree& root);
 
  template<typename T>
  std::shared_ptr<T> deserialize(const std::string& json) {
    boost::property_tree::ptree root;
    gen_utils::deserialize(json, root);
    std::shared_ptr<T> obj = std::make_shared<T>();
    T::from_property_tree(root, obj);
    return obj;
  }
 
  // ------------------------- VALUE RECONCILATION ----------------------------
 
  // TODO: refactor common template code
  template <class T, typename std::enable_if<std::is_same<T, std::string>::value, T>::type* = nullptr>
  boost::optional<T> reconcile(const boost::optional<T>& val1, const boost::optional<T>& val2, boost::optional<bool> resolve_defined, boost::optional<bool> resolve_true, boost::optional<bool> resolve_max, const std::string& err_msg = "") {
 
    // check for equality
    if (val1 == val2) return val1;
 
    // resolve one value none
    if (val1 == boost::none || val2 == boost::none) {
      if (resolve_defined != boost::none && *resolve_defined == false) return boost::none;
      else return val1 == boost::none ? val2 : val1;
    }
 
    throw std::runtime_error(std::string("Cannot reconcile strings: ") + boost::lexical_cast<std::string>(val1) + std::string(" vs ") + boost::lexical_cast<std::string>(val2) + (!err_msg.empty() ? std::string(". ") + err_msg : std::string("")));
  }
  template <class T, typename std::enable_if<std::is_same<T, std::string>::value, T>::type* = nullptr>
  boost::optional<T> reconcile(const boost::optional<T>& val1, const boost::optional<T>& val2, const std::string& err_msg = "") {
    return reconcile(val1, val2, boost::none, boost::none, boost::none, err_msg);
  }
 
  template <class T, typename std::enable_if<std::is_integral<T>::value, T>::type* = nullptr>
  boost::optional<T> reconcile(const boost::optional<T>& val1, const boost::optional<T>& val2, boost::optional<bool> resolve_defined, boost::optional<bool> resolve_true, boost::optional<bool> resolve_max, const std::string& err_msg = "") {
 
    // check for equality
    if (val1 == val2) return val1;
 
    // resolve one value none
    if (val1 == boost::none || val2 == boost::none) {
      if (resolve_defined != boost::none && *resolve_defined == false) return boost::none;
      else return val1 == boost::none ? val2 : val1;
    }
 
    // resolve different booleans
    if (resolve_true != boost::none) return *val1 == *resolve_true ? val1 : val2; // resolve conflicting booleans to the preferred value
 
    // resolve different numbers
    if (resolve_max != boost::none) return *resolve_max ? std::max(*val1, *val2) : std::min(*val1, *val2);
 
    // cannot reconcile
    throw std::runtime_error(std::string("Cannot reconcile integrals: ") + boost::lexical_cast<std::string>(val1) + std::string(" vs ") + boost::lexical_cast<std::string>(val2) + (!err_msg.empty() ? std::string(". ") + err_msg : std::string("")));
  }
  template <class T, typename std::enable_if<std::is_integral<T>::value, T>::type* = nullptr>
  boost::optional<T> reconcile(const boost::optional<T>& val1, const boost::optional<T>& val2, const std::string& err_msg = "") {
    return reconcile(val1, val2, boost::none, boost::none, boost::none, err_msg);
  }
 
  template <class T>
  std::vector<T> reconcile(const std::vector<T>& v1, const std::vector<T>& v2, const std::string& err_msg = "") {
 
    // check for equality
    if (v1 == v2) return v1;
 
    // resolve one vector empty
    if (v1.empty()) return v2;
    if (v2.empty()) return v1;
 
    // otherwise cannot reconcile
    throw std::runtime_error("Cannot reconcile vectors" + (!err_msg.empty() ? std::string(". ") + err_msg : std::string("")));
  }
 
  // ------------------------- THREAD POLLER ----------------------------
 
  // WARNING: Only destroy a thread_poller from a thread other than its own pool thread.
  // (e.g. a listener callback running on the poll thread, drops the last owning reference/unique_ptr
  // to the poller.)
  class thread_poller {
  public:
    thread_poller();
    virtual ~thread_poller();
 
    bool is_polling() const { return m_is_polling; }
    void set_is_polling(bool is_polling);
    void request_is_polling(bool is_polling);
 
    void set_period_in_ms(uint64_t period_ms) { m_poll_period_ms = period_ms; }
    virtual void poll() = 0;
    void wait_for_callbacks_idle();
 
    class announce_scope {
    public:
      explicit announce_scope(thread_poller& poller);
      ~announce_scope();
      announce_scope(const announce_scope&) = delete;
      announce_scope& operator=(const announce_scope&) = delete;
    private:
      thread_poller& m_poller;
    };
 
  protected:
    std::string m_name;
    boost::recursive_mutex m_mutex;
    boost::mutex m_polling_mutex;              // guards the interruptible periodic sleep (m_poll_cv)
    boost::mutex m_lifecycle_mutex;            // guards m_poll_loop_running/m_poll_thread_id and start/stop coordination
    boost::thread::id m_poll_thread_id;        // id of the currently running loop thread; guarded by m_lifecycle_mutex
    std::atomic<bool> m_is_polling;
    bool m_poll_loop_running;                  // guarded by m_lifecycle_mutex
    std::atomic<uint64_t> m_poll_period_ms;
    boost::condition_variable m_poll_cv;       // periodic-sleep interrupt
    boost::condition_variable m_lifecycle_cv;  // notified (under m_lifecycle_mutex) when the loop actually exits
    boost::mutex m_announce_mutex;             // guards m_announce_count
    boost::condition_variable m_announce_cv;   // notified (under m_announce_mutex) when m_announce_count reaches 0
    int m_announce_count = 0;                  // number of announce_scope instances currently alive, across all threads
 
    void init_common(const std::string& name);
    void run_poll_loop();
  };
}
#endif /* gen_utils_h */