C++使用模板类实现任意类型switch和变量case

switch statement

Syntax

switch (

)

case:

default:

case

:

default

:

switch(100)
enum color {r, g, b}
switch(r)
switch(int n = 1)
switch(int n = {1})

switch(num){
  case 1:
    int n = 0; // error: jump bypasses variable initialization
    break;
  default:
    break;
}

// 蓝图1
select(condition, {
  {"case1", []() {
    // code goes here
  }},
  {"case2", []() {
    // code goes here
  }}
});
// 蓝图2
select(condition)
  .found("case1", []() {
    // code goes here
  })
  .found("case2", []() {
    // code goes here
  })
  .others([]() {
    // default
  });

#include <functional>
#include <map>

template <typename Ty>
class Switch {
 public:
  Switch(){}

  explicit Switch(const Ty& target)
      : target_(target) {}

  Switch& found(const Ty& _case, const std::function<void(void)>& callback) {
    reflections_[_case] = callback;
    return *this;
  }
  
 private:
  const Ty& target_;
  std::map<const Ty, std::function<void(void)>> reflections_;
};

template <typename Ty>
Switch<Ty> select(const Ty& expression) {
  return Switch<Ty>(expression);
}

select(std::string("condition"))
  .found ...

inline void done() {
    auto kv = reflections_.find(target_);
    if (kv != reflections_.end()) {
      // found
      auto scope = kv->second;
      scope();
    } else if (has_others_scope_) {
      // not found, call others
      others_();
    }
  }

inline void others(const Scope& callback) {
    has_others_scope_ = true;
    others_ = callback;
    this->done();
  }

typedef std::function<void(void)> Scope;
  typedef std::map<const Ty, Scope> Reflections;

#define printl(line) printf((line)); printf("\n")
  std::string condition("windows");

  // match std::string
  select(condition)
    .found("apple", []() {
      printl("it's apple");
    })
    .found("windows", []() {
      printl("it's windows");
    })
    .found("linux", []() {
      printl("it's linux");
    }).done();

  // match int
  select(100)
    .found(10, []() {
      printl("it's 10");
    })
    .found(20, []() {
      printl("it's 20");
    })
    .others([]() {
      printl("nothing found");
    });

  // output
  // it's windows
  // nothing found

class User {
 public:
  explicit User(int age) : age_(age) {}

  bool operator<(const User& user) const { return this->age_ < user.age(); }

  int age() const { return age_; }

 private:
  int age_;
};

User u1(20), u2(22), ux(20);
  select(ux)
    .found(u1, []() {
      printl("it's u1");
    })
    .found(u2, []() {
      printl("it's u2");
    }).done();
  // it's u2

bool operator<(const User& user) const { return this->age_ < user.age(); }

auto kv = reflections_.find(target_);

struct _LIBCPP_TYPE_VIS_ONLY less : binary_function<_Tp, _Tp, bool>
{
    _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY 
    bool operator()(const _Tp& __x, const _Tp& __y) const
        {return __x < __y;}
};

select("condition")
  .found("case", ...)
  .done();

Switch& found(const Ty& _case, const Scope& callback)

select(std::string("condition"))
  .found("case", ...)
  .done();

#ifndef PROGRAM_OPTIONS_SWITCH_HPP_
#define PROGRAM_OPTIONS_SWITCH_HPP_

#include <functional>
#include <map>

namespace program_options {

/**
* @brief The Switch template class.
* @param Ty The target type.
*/
template <typename Ty>
class Switch {
 public:
typedef std::function<void(void)> Scope;
  typedef std::map<const Ty, Scope> Reflections;

  Switch() : has_others_scope_(false) {}

  explicit Switch(const Ty& target)
      : target_(target), has_others_scope_(false) {}

  /**
   * @brief Create a case block with an expression and a callback function.
   * @param _case The case expression, variable is allowed.
   * @param callback The callback function, can be a lambda expression.
   * @return The current Switch instance.
   */
  Switch& found(const Ty& _case, const Scope& callback) {
    reflections_[_case] = callback;
    return *this;
  }

  /**
   * @brief Create a default block with a callback function,
   *        if no cases matched, this block will be called.
   * @param callback
   */
inline void others(const Scope& callback) {
    has_others_scope_ = true;
    others_ = callback;
    this->done();
  }

  /**
   * @brief Finish the cases,
   * others() will call this method automatically.
   */
inline void done() {
    auto kv = reflections_.find(target_);
    if (kv != reflections_.end()) {
      // found
      auto scope = kv->second;
      scope();
    } else if (has_others_scope_) {
      // not found, call others
      others_();
    }
  }

  /**
   * @brief Combine the cases to this Switch from another Switch.
   *        Note that this two Switch should be the same template.
   * @param _switch Another Switch instance.
   * @return
   */
  inline Switch& combine(const Switch& _switch) {
    for (auto kv : _switch.reflections()) {
      this->reflections_[kv.first] = kv.second;
    }
    return *this;
  }

  /**
   * @brief Return the case-callback pairs.
   * @return
   */
  inline Reflections reflections() const { return reflections_; }

 private:
  const Ty& target_;
  bool has_others_scope_;
  Scope others_;
  Reflections reflections_;
};

/**
 * @brief Define which expression does the Switch match.
 * @param expression
 * @return
 */
template <typename Ty>
Switch<Ty> select(const Ty& expression) {
  return Switch<Ty>(expression);
}
}

#endif  // PROGRAM_OPTIONS_SWITCH_HPP_