if (get_level() == "L1" || get_level() == "L2" || ... || get_level() == "L10") {
  ...
}

auto level = get_level();
if (level == "L1" || level == "L2" || ... || level == "L10") {
  ...
}

auto level = get_level();
auto type  = get_type();
if ( (level == "L1" || level == "L2" || ... || level == "L10") || (type == TypeFirst || type == TypeSecond)) {
  ...
}

static std::unordered_set<std::string> levels = {
  "L1",
  "L2",
  ...
  "L10",
};
static std::unordered_set<Type> types = {
  TypeFirst,
  TypeSecond,
};
if (levels.contains(get_level()) || types.contains(get_type())) {
  ...
}

#include <string_view>
#include <type_traits>
#include <initializer_list>
#include <algorithm>

template <typename InputIt, typename T>
bool c_contains(InputIt begin, InputIt end, T &&value) { // (1)
  return std::find(begin, end, std::forward<T>(value)) != end;
}

template <typename C = std::initializer_list<std::string_view>, typename T>
bool c_contains(const C &c, T &&value) {                                 // (2)
  return c_contains(std::begin(c), std::end(c), std::forward<T>(value)); // 调用(1)
}

template <typename U, typename T,
          std::enable_if_t<!std::is_same_v<U, const char *>, int *> = nullptr>
bool c_contains(std::initializer_list<U> c, T &&value) {
  return c_contains(c.begin(), c.end(), std::forward<T>(value)); // 调用(2)
}

int foo() {
  if (c_contains({"L1", "L2", ... , "L10"}, get_level()) ||
      c_contains({TypeFirst, TypeSecond}, get_type())) {
    return 0;
  }
  return 1;
}

struct Student {
  std::string name;
  float       score1;
  float       score2;
};

std::string f = "Tom@20@0.5@0.6|John@21@0.6@0.6|Jean@16@0.2@0.1";
std::map<std::string, Student> student_map;
// 简洁: 体现在类似的两层数据表达在调用解析的时候，只需要这么简单。
// 抽象程度高: 体现在解析规则的lambda表达式可以支持多种builtin类型的自由组合，用户可以自己根据字符串格式要求自行声明对应格式的lambda表达式
//           然后该会将对应字符串转换成要求的类型，然后触发lambda调用。
// 解释度高: 体现在通过lambda表达式的声明就表达的对应字符串的格式，可以不再进行额外的注释，例如下面的例子，每个字段的含义可以通过lambda表达式
//          的函数声明体现。
SplitString2ValueVec(f, '|', '@', [&](std::string name, int age, float score1, float score2) {
  if (age > 18) {
    student_map.insert(name, Student{name, score1, score2});
  }
})

#pragma once
#include <tuple>
#include <string>
#include <vector>
#include <string.h>
#include <boost/callable_traits.hpp>
#include <boost/type_traits.hpp>
#include <boost/utility/string_view.hpp>
#include <folly/Traits.h>
#include <folly/functional/ApplyTuple.h>
#include <absl/utility/utility.h>
#include <absl/strings/str_split.h>
#include <absl/strings/numbers.h>

namespace common {
namespace common_detail {
FOLLY_CREATE_HAS_MEMBER_TYPE_TRAITS(has_key_type_traits, key_type);

template <typename T, typename = void>
struct Conv2Type;

template <typename T>
struct Conv2Type<T, std::enable_if_t<std::is_convertible<T, absl::string_view>::value>> {
  bool operator()(absl::string_view m, T *v) {
    *v = T(m);
    return true;
  }
};

template <typename T>
struct Conv2Type<T, std::enable_if_t<std::is_integral<T>::value>> {
  bool operator()(absl::string_view m, T *v) { return absl::SimpleAtoi(m, v); }
};

template <>
struct Conv2Type<double> {
  bool operator()(absl::string_view m, double *v) { return absl::SimpleAtod(m, v); }
};

template <>
struct Conv2Type<float> {
  bool operator()(absl::string_view m, float *v) { return absl::SimpleAtof(m, v); }
};

template <>
struct Conv2Type<bool> {
  bool operator()(absl::string_view m, bool *v) { return absl::SimpleAtob(m, v); }
};

template <size_t N, typename Tuple, typename It, bool IsEnd = (N == std::tuple_size<Tuple>::value)>
struct TupleAssign {
  static bool assign(It it, It end, Tuple &v) {
    static_assert(N < std::tuple_size<Tuple>::value, "bad assign index");
    if (it == end) {
      return false;
    }
    auto vv = *it;
    return TupleAssign<N + 1, Tuple, It>::assign(++it, end, v) &&
           Conv2Type<typename std::tuple_element<N, Tuple>::type>()(vv, &std::get<N>(v));
  }
};

template <size_t N, typename Tuple, typename It>
struct TupleAssign<N, Tuple, It, true> {
  static bool assign(It, It, Tuple &) { return true; }
};

template <typename Callback>
using SplitString2ValueVecCallbackReturnType =
    std::enable_if<std::is_same<void, boost::callable_traits::return_type_t<Callback>>::value ||
                   std::is_same<bool, boost::callable_traits::return_type_t<Callback>>::value>;

template <typename T>
struct RemoveTupleElementReference;

template <typename... T>
struct RemoveTupleElementReference<std::tuple<T...>> {
  using type = std::tuple<boost::remove_cv_ref_t<T>...>;
};

template <typename Callback>
struct SplitString2ValueVecCallbackArgsType {
  using type = typename RemoveTupleElementReference<boost::callable_traits::args_t<Callback>>::type;
};

template <typename T>
struct IsVec : std::false_type { };

template <typename T>
struct IsVec<std::vector<T>> : std::true_type { };

template <typename Callback>
using IsCallbackArgsOnly1Vec = folly::Conjunction<
    folly::bool_constant<std::tuple_size<boost::callable_traits::args_t<Callback>>::value == 1>,
    IsVec<boost::remove_cv_ref_t<
        typename std::tuple_element<0, boost::callable_traits::args_t<Callback>>::type>>>;

struct TupleHasReferenceImpl {
  template <typename... T, typename ReturnType = folly::Disjunction<folly::Conjunction<
                               std::is_lvalue_reference<T>,
                               folly::Negation<std::is_const<std::remove_reference_t<T>>>>...>>
  static ReturnType apply(std::tuple<T...> &&) {
    return {};
  }
};

template <typename Tuple>
using TupleHasReference = decltype(TupleHasReferenceImpl::apply(std::declval<Tuple>()));

template <typename Callback,
          bool HasReference = TupleHasReference<boost::callable_traits::args_t<Callback>>::value>
struct ApplyInvoke {
 public:
  constexpr decltype(auto)
      operator()(Callback &&                                                     cb,
                 typename SplitString2ValueVecCallbackArgsType<Callback>::type &&tuple) const {
    return folly::apply(std::forward<Callback>(cb), std::move(tuple));
  }
};

template <typename Callback>
struct ApplyInvoke<Callback, true> {
 public:
  constexpr decltype(auto)
      operator()(Callback &&                                                     cb,
                 typename SplitString2ValueVecCallbackArgsType<Callback>::type &&tuple) const {
    auto tuple2 = folly::forward_tuple(tuple);
    return folly::apply(std::forward<Callback>(cb), std::move(tuple2));
  }
};

template <typename Callback, typename STRING, typename IsSupport = void>
struct SplitString2ValueVec;

template <typename Callback, typename STRING>
struct SplitString2ValueVec<
    Callback, STRING,
    typename std::enable_if<
        !IsCallbackArgsOnly1Vec<Callback>::value &&
        std::is_same<void, boost::callable_traits::return_type_t<Callback>>::value>::type> {
  // 返回值为void类型的回调函数时:
  void operator()(const STRING &v, char key_value_pair_delimiter, char key_value_delimiter,
                  Callback &&cb) {
    for (const auto &kv_token : absl::StrSplit(v, key_value_pair_delimiter, absl::SkipEmpty())) {
      typename SplitString2ValueVecCallbackArgsType<Callback>::type tuple;
      auto sp = absl::StrSplit(kv_token, key_value_delimiter);
      if (TupleAssign<0, decltype(tuple), typename decltype(sp)::const_iterator>::assign(
              sp.begin(), sp.end(), tuple)) {
        ApplyInvoke<Callback> {}(std::forward<Callback>(cb), std::move(tuple));
      }
    }
  }
};

template <typename Callback, typename STRING>
struct SplitString2ValueVec<
    Callback, STRING,
    typename std::enable_if<
        !IsCallbackArgsOnly1Vec<Callback>::value &&
        std::is_same<bool, boost::callable_traits::return_type_t<Callback>>::value>::type> {
  // 返回值为bool类型的回调函数时，返回值为false时，中断解析。
  void operator()(const STRING &v, char key_value_pair_delimiter, char key_value_delimiter,
                  Callback &&cb) {
    for (const auto &kv_token : absl::StrSplit(v, key_value_pair_delimiter, absl::SkipEmpty())) {
      typename SplitString2ValueVecCallbackArgsType<Callback>::type tuple;
      auto sp = absl::StrSplit(kv_token, key_value_delimiter);
      if (TupleAssign<0, decltype(tuple), typename decltype(sp)::const_iterator>::assign(
              sp.begin(), sp.end(), tuple)) {
        if (!ApplyInvoke<Callback> {}(std::forward<Callback>(cb), std::move(tuple))) {
          break;
        }
      }
    }
  }
};

template <typename Callback, typename STRING>
struct SplitString2ValueVec<
    Callback, STRING,
    typename std::enable_if<
        IsCallbackArgsOnly1Vec<Callback>::value && // 参数为std::vector<T>时
        std::is_same<void, boost::callable_traits::return_type_t<Callback>>::value>::type> {
  // 返回值为void类型的回调函数时:
  void operator()(const STRING &v, char key_value_pair_delimiter, char key_value_delimiter,
                  Callback &&cb) {
    for (const auto &kv_token : absl::StrSplit(v, key_value_pair_delimiter, absl::SkipEmpty())) {
      typename SplitString2ValueVecCallbackArgsType<Callback>::type tuple;
      using element_type = typename std::tuple_element<0, decltype(tuple)>::type;
      bool ok            = true;
      for (const auto &item : absl::StrSplit(kv_token, key_value_delimiter)) {
        typename element_type::value_type v;
        if (!Conv2Type<decltype(v)> {}(item, &v)) {
          ok = false;
          break;
        }
        std::get<0>(tuple).push_back(std::move(v));
      }
      if (ok) {
        ApplyInvoke<Callback> {}(std::forward<Callback>(cb), std::move(tuple));
      }
    }
  }
};

template <typename Callback, typename STRING>
struct SplitString2ValueVec<
    Callback, STRING,
    typename std::enable_if<
        IsCallbackArgsOnly1Vec<Callback>::value && // 参数为std::vector<T>时
        std::is_same<bool, boost::callable_traits::return_type_t<Callback>>::value>::type> {
  // 返回值为bool类型的回调函数时，返回值为false时，中断解析。
  void operator()(const STRING &v, char key_value_pair_delimiter, char key_value_delimiter,
                  Callback &&cb) {
    for (const auto &kv_token : absl::StrSplit(v, key_value_pair_delimiter, absl::SkipEmpty())) {
      typename SplitString2ValueVecCallbackArgsType<Callback>::type tuple;
      using element_type = typename std::tuple_element<0, decltype(tuple)>::type;
      bool ok            = true;
      for (const auto &item : absl::StrSplit(kv_token, key_value_delimiter)) {
        typename element_type::value_type v;
        if (!Conv2Type<decltype(v)> {}(item, &v)) {
          ok = false;
          break;
        }
        std::get<0>(tuple).push_back(std::move(v));
      }
      if (ok) {
        if (!ApplyInvoke<Callback> {}(std::forward<Callback>(cb), std::move(tuple))) {
          break;
        }
      }
    }
  }
};

template <typename Callback, typename StringType>
inline void SplitString2ValueVecF(const StringType &v, char vec_vec_delimiter, char value_delimiter,
                                  Callback &&cb) {
  SplitString2ValueVec<Callback, StringType,
                       typename SplitString2ValueVecCallbackReturnType<Callback>::type> {}(
      v, vec_vec_delimiter, value_delimiter, std::forward<Callback>(cb));
}

template <typename Callback>
inline void SplitString2ValueVecF(const butil::StringPiece &v, char vec_vec_delimiter,
                                  char value_delimiter, Callback &&cb) {
  SplitString2ValueVecF<Callback, absl::string_view>(absl::string_view {v.data(), v.length()},
                                                     vec_vec_delimiter, value_delimiter,
                                                     std::forward<Callback>(cb));
}

template <typename Callback>
inline void SplitString2ValueVecF(const boost::string_view &v, char vec_vec_delimiter,
                                  char value_delimiter, Callback &&cb) {
  SplitString2ValueVecF<Callback, absl::string_view>(absl::string_view {v.data(), v.length()},
                                                     vec_vec_delimiter, value_delimiter,
                                                     std::forward<Callback>(cb));
}

template <typename MAP, typename STRING>
struct SplitString2KeyValueMap {
  void operator()(const STRING &v, char key_value_pair_delimiter, char key_value_delimiter,
                  MAP &map) {
    static_assert(common_detail::has_key_type_traits<MAP>::value,
                  "map type must have key_type alias.");
    static_assert(absl::strings_internal::HasMappedType<MAP>::value,
                  "map type must have mapped_type alias.");
    for (const auto &kv_token : absl::StrSplit(v, key_value_pair_delimiter, absl::SkipEmpty())) {
      std::pair<absl::string_view, absl::string_view> kv =
          absl::StrSplit(kv_token, absl::MaxSplits(key_value_delimiter, 1));
      typename MAP::key_type    key = {};
      typename MAP::mapped_type val = {};
      if (common_detail::Conv2Type<decltype(key)>()(kv.first, &key) &&
          common_detail::Conv2Type<decltype(val)>()(kv.second, &val)) {
        map.emplace(std::move(key), std::move(val));
      }
    }
  }
};

template <typename MAP>
struct SplitString2KeyValueMap<MAP, butil::StringPiece> {
  void operator()(const butil::StringPiece &v, char key_value_pair_delimiter,
                  char key_value_delimiter, MAP &map) {
    SplitString2KeyValueMap<MAP, absl::string_view>()(
        absl::string_view {v.data(), v.size()}, key_value_pair_delimiter, key_value_delimiter, map);
  }
};
} // namespace common_detail

// SplitString2ValueVec 可以将字符串按照回调lambda表达的的输入参数的类型，按需分段解析成对应的
// 类型，然后调用对应的lambda表达式。可以极大地简化字符串解析。
//
// vec_vec_delimiter 为外层字符串格式的分隔符
// value_delimiter 为内层字符串格式的分隔符
//
// 例如：当 vec_vec_delimiter='@',
// value_delimiter=','，被解析字符串为"Tom,1,0.5@Jame,2,0.8@Bean,3,1.0"， 回调函数为 :
// [](std::string name, int index, double score) {
//    std::cout << "name: " << name << " index:" << index << " score:" << score << std::endl;
// }
// 时，则会将字符串解析为按外层分隔符'@'解析为3段，然后再按内层分隔符','将每一段解析成3个三个段，
// 然后分别转换为对应类型std::string int double，然后调用对应的回调函数。然后回调函数分别输出:
// name:Tom index:1 score:0.5
// name:Jame index:2 score:0.8
// name:Bean index:3 score:1.0
//
// 当第二层字符串为同一类型T且个数不定时，传入的lambda可以将接受的参数指定为对应类型的std::vector<T>，
// 这样该函数会将第二层字符串解析为对应类型并传入lambda。
//
// 例如:
// std::string xxx = "1.0@1.1@1.2|2.1@2.2@2.3@2.4";
// common::SplitString2ValueVec(xxx, '|', '@', [](std::vector<double> vec) {
//   std::cout << "vec size=" << vec.size();
//   for (const auto & v : vec) {
//      std::cout << " v=" << v << ",";
//   };
//   std::cout << std::endl;
// });
// 则会输出：
// vec size=3 v=1.0 v=1.1 v=1.2
// vec size=4 v=2.1 v=2.2 v=2.3 v=2.4
template <typename Callback, typename StringType>
inline void SplitString2ValueVec(const StringType &v, char vec_vec_delimiter, char value_delimiter,
                                 Callback &&cb) {
  common_detail::SplitString2ValueVecF(v, vec_vec_delimiter, value_delimiter,
                                       std::forward<Callback>(cb));
}
// 例如：当 key_value_pair_delimiter='@', key_value_delimiter='='，map=std::map<std::string,
// int>时， 将 "abc=1@efg=2@xyz=3" 拆解成 map = { {"abc", 1}, {"efg", 2}, {xyz, 3} }
// 支持任意map类型，比如:
//      std::map<std::string, std::string>
//      std::map<int, int>
//      std::unordered_map<int, int>
// 等
template <typename MAP, typename STRING>
inline void SplitString2KeyValueMap(const STRING &v, char key_value_pair_delimiter,
                                    char key_value_delimiter, MAP &map) {
  common_detail::SplitString2KeyValueMap<MAP, STRING>()(v, key_value_pair_delimiter,
                                                        key_value_delimiter, map);
}
} // namespace common

// 所在头文件：
#include <folly/functional/Partial.h>

template <typename F, typename... Args>
auto partial(F&& f, Args&&... args);

// 跟 std::bind() 相似，但是不需要使用placeholders来进行参数绑定。
// e.g.
//
// auto p = folly::partial(&Foo::method, foo_pointer);
// p();
//
// folly::partial(Foo, 1, 2)(3); // is equivalent to `Foo(1, 2, 3);`

// 所在头文件：
#include <folly/ConstexprMath.h>

// 其中包含一些模板类，可以帮助在编译期推导 max、min、abs、pow、ceil、log2_ceil、log2等常用数学方法。

#include <folly/synchronization/detail/Spin.h>

// 非常简单易用的 spin 循环实现，需要用到的之后可以直接引用
folly::detail::spin_pause_until();
folly::detail::spin_yield_until();

#include <folly/MicroLock.h>
// 或者
#include <folly/synchronization/SmallLocks.h>

// 通常从性能角度出发，应该使用 std::mutex（对锁竞争处理的更好）， 如果为了节省内存，可以使用 folly::MicroLock ，
// 其只使用 4B 空间。
// 其具有常规的lock()/try_lock()/unlock()方法。

#include <folly/MicroSpinLock.h>
// 或者
#include <folly/synchronization/MicroSpinLock.h>

// folly::MicroSpinLock 是一个极简单的 spinlock 实现，采用最简单的while-cas模式。通常不应该被使用。

#include <folly/synchronization/PicoSpinLock.h>

// folly::PicoSpinLock 也是一个最简单的while-cas模式实现的spinlock，通常不应该被使用。但是其使用一个整形数
// 作为spin的载体，其大部分bit可以用来存储数据，剩余bit用来记录lock状态，如果非常需要内存紧凑，可以考虑使用。

#include <folly/synchronization/RWSpinLock.h>

// folly::RWSpinLock 是一个简单的读写spinlock实现，并且支持锁升级、降级逻辑，其升降级遵循boost的 https://www.boost.org/doc/libs/1_47_0/doc/html/thread/synchronization.html#thread.synchronization.mutex_concepts.upgrade_lockable 语义，其可以通过 lock_upgrade() + unlock_upgrade_and_lock() 完成读锁到写锁的升级。

// 所在头文件：
#include <folly/synchronization/Baton.h>

// Baton 通常用作线程间同步、等待、通知的标识符号，常用姿势是，一些线程调用 wait() 方法等待另
// 一些线程完成某项工作，其完成以后调用 post() 方法进行通知。 其跟一般PV信号量的区别是，Baton
// 更轻量化、通知策略更简单(没有FILO/FIFO等策略)、仅能够通知一次，在简单场景中更高效。
//
// 声明：MayBlock表示十分会被长时间block，其实就是内部衡量是否需要一直spin的依据，
// 否则会调用 futex 相关 syscall 释放 cpu
// Atom 指示使用什么原子操作的实现，通常使用 std::atomic 即可
template <bool MayBlock = true, template <typename> class Atom = std::atomic>
class Baton;

// 常规用法：
// Baton 用于同步线程间的PV (block/wakeup)，但是不像 semaphores
// 信号量那样可以多次pv，baton 仅支持单次pv操作，folly::Future 中的
// block/wakeup 就是使用 Baton<> 来实现的。

Baton<> baton;
Baton<false> spin_baton;

// 其基本方法有：
bool Baton<>::ready(); // 测试是否已经被标记置位
void Baton<>::post();  // 置位
bool Baton<>::try_wait(); // 等同 ready
// 等待直到被置位，可以传入一个 wait_options 来控制 spin 的最大时间，默认2us
void Baton<>::wait(const WaitOptions& opt = wait_options());

// 所在头文件：
#include <folly/synchronization/SaturatingSemaphore.h>

// folly::SaturatingSemaphore 是一个经典的信号量实现，可以支持多个poster和多个waiter同时调用PV。
// 而且可以对一个SaturatingSemaphore可以多次设置post状态，而且幂等（但是不累积，设置成post状态后，
// 所有wait()调用都会通过，简而言之就是只有PV状态，而没有对应的计数），然后可以通过reset()方法进行恢复。
//
// 其跟Baton的主要区别就是Baton只支持有且仅有一个poster，SaturatingSemaphore支持多个，且可以并发调用post()

///  方法：
///   bool ready():
///     Returns true if the flag is set by a call to post, otherwise false.
///     Equivalent to try_wait, but available on const receivers.
///   void reset();
///     Clears the flag.
///   void post();
///     Sets the flag and wakes all current waiters, i.e., causes all
///     concurrent calls to wait, try_wait_for, and try_wait_until to
///     return.
///   void wait(
///       WaitOptions opt = wait_options());
///     Waits for the flag to be set by a call to post.
///   bool try_wait();
///     Returns true if the flag is set by a call to post, otherwise false.
///   bool try_wait_until(
///       time_point& deadline,
///       WaitOptions& = wait_options());
///     Returns true if the flag is set by a call to post before the
///     deadline, otherwise false.
///   bool try_wait_for(
///       duration&,
///       WaitOptions& = wait_options());
///     Returns true if the flag is set by a call to post before the
///     expiration of the specified duration, otherwise false.

#include <folly/synchronization/LifoSem.h>

// folly::LifoSem 相对于 folly::SaturatingSemaphore 维护了一个通知的顺序，后入先出，主要是尽快通知较活跃的线程。
// 并且post()可以指定通知的个数，不像 folly::SaturatingSemaphore post()会通知全部的wait().
//
// 其内部用一个对象池维护了waiter的相对顺序，然后按顺序进行通知。

// 所在头文件:
#include <folly/synchronization/Hazptr.h>

// hazard pointer 支持一写多读
// 其实现依赖thread local机制。
// 其原始的 hazard pointer 并没有直接暴露给用户来进行操作，而是给用户提供一个 hazptr_holder 对象进行持有 hazard pointer

// AtomicStruct 可以原子地操作一个大小小于等于8byte的对象，其内部原理就是把对象转换成对应大小的int类型，
// 使用std::atmoic<int>来操作。是一个比较有助的封装。对象大小大于8byte的则无法使用该封装。
#include <folly/synchronization/AtomicStruct.h>

struct A {
  int32_t a;
};

folly::AtomicStruct<A> a;
auto xx = a.load();

// in folly/SingletonThreadLocal.h
#define FOLLY_DECLARE_REUSED(name, ...)                                        \
  struct __folly_reused_type_##name {                                          \
    __VA_ARGS__ object;                                                        \
  };                                                                           \
  auto& name =                                                                 \
      ::folly::SingletonThreadLocal<__folly_reused_type_##name>::get().object; \
  auto __folly_reused_g_##name = ::folly::makeGuard([&] { name.clear(); })

#include <folly/SingletonThreadLocal.h>

void traverse_perform(int root);
template <typename F>
void traverse_each_child_r(int root, F const&);
void traverse_depthwise(int root) {
  // preserves some of the memory backing these per-thread data structures
  FOLLY_DECLARE_REUSED(seen, std::unordered_set<int>);
  FOLLY_DECLARE_REUSED(work, std::vector<int>);
  // example algorithm that uses these per-thread data structures
  work.push_back(root);
  while (!work.empty()) {
    root = work.back();
    work.pop_back();
    seen.insert(root);
    traverse_perform(root);
    traverse_each_child_r(root, [&](int item) {
      if (!seen.count(item)) {
        work.push_back(item);
      }
    });
  }
}