common.hpp

Go to the documentation of this file.

#ifndef INDIGOX_UTILS_COMMON_HPP
#define INDIGOX_UTILS_COMMON_HPP

#include <algorithm>
#include <iterator>
#include <memory>
#include <string>
#include <type_traits>

// forward definitions of serilisation stuff
namespace cereal {
  class access;
  class PortableBinaryInputArchive;
  class PortableBinaryOutputArchive;
  class JSONInputArchive;
  class JSONOutputArchive;
  template <class T> class construct;
} // namespace cereal

namespace indigox::utils {
  enum class Option {
    Yes = 1,
    No = Yes << 1,
    Auto = Yes << 2,
    Default = Yes << 3,
    All = Yes << 4,
    Some = Yes << 5,
    None = Yes << 6
  };

  inline Option operator|(Option l, Option r) {
    using under = std::underlying_type<Option>::type;
    return static_cast<Option>(static_cast<under>(l) | static_cast<under>(r));
  }

  inline Option operator&(Option l, Option r) {
    using under = std::underlying_type<Option>::type;
    return static_cast<Option>(static_cast<under>(l) & static_cast<under>(r));
  }

  std::string ToUpper(const std::string &s);

  std::string ToLower(const std::string &s);

  std::string ToUpperFirst(const std::string &s);

  std::string GetRandomString(size_t length, size_t seed = 0);

  template <typename T, typename __Iter>
  inline __Iter WeakContainsShared(__Iter b, __Iter e, std::shared_ptr<T> x) {
    static_assert(
        std::is_same<typename std::weak_ptr<T>,
                     typename std::iterator_traits<__Iter>::value_type>::value,
        "__Iter must be iterator over std::weak_ptr<T>.");
    if (!x) return e;
    return std::find_if(b, e,
                        [x](std::weak_ptr<T> _x) { return _x.lock() == x; });
  }

  //  template<typename T>
  //  inline bool IsNull(std::shared_ptr<T> t) {
  //    return !(t && *t);
  //  }

} // namespace indigox::utils

#endif /* INDIGOX_UTILS_COMMON_HPP */