is there a better implementation to deal switches? - c++

Question

I had a class type named reply, its form like this:
class reply {
public:
enum class type {
error = 0,
bulk_string = 1,
simple_string = 2,
null = 3,
integer = 4,
array = 5
};
public:
type get_type(void) const {
return type_;
}
private:
type type_;
};
The reply instance would be returned by other functions, so I would deal with the reply with probing each possible value of the call of get_type. The first solution is to use switch case, but I would like to encapsulate it using 'OOP' thinking as follows:
template<typename Handlers, typename Handlers::type*...types>
class handlers {
private:
static constexpr typename Handlers::type* dealers[] = { types... };
public:
static void deal(const reply& reply) {
dealers[int(reply.get_type())](reply);
}
};
template<typename Handlers>
class handle{
public:
using handles = handlers<Handlers, Handlers::error_handle,
Handlers::bulk_string_handle, Handlers::simple_string_handle,
Handlers::null_handle, Handlers::integer_handle,
Handlers::array_handle>;
};
class handler
{
public:
static void error_handle(const reply&) {
std::cout << "error_handle" << std::endl;
}
static void bulk_string_handle(const reply&) {
std::cout << "bulk_string_handle" << std::endl;
}
static void simple_string_handle(const reply&) {
std::cout << "simple_string_handle" << std::endl;
}
static void null_handle(const reply&) {
std::cout << "null_handle" << std::endl;
}
static void integer_handle(const reply&) {
std::cout << "integer_handle" << std::endl;
}
static void array_handle(const reply&) {
std::cout << "array_handle" << std::endl;
}
public:
using type = decltype(error_handle);
using handles = handle<handler>::handles;
};
Finally, I can deal the reply like this:
int main()
{
reply rep;
handler::handles::deal(rep);
return 0;
}
Note: Each reply has its handler.
What I focus on is whether there is better way to adapt to the solution?

Answer 1

Design at least "central points" as possible. Concentrate on making it easy to add new reply types, the design will flow from that assumption. Create separated parts associated with each reply with a single one central point that choose the handler. The central point is called a factory and small parts implement the same interface.
struct handler {
// I do not know, maybe this should store the reply?
// No idea.
virtual void handle(const reply&);
virtual ~handler();
};
struct error_handler : handler {
void handle(const reply&) { /* blabla */ }
handler construct() { return error_handler(); }
};
/* etc. for each handle type */
// TODO: convert to static array to save dynamic allocatiosn
std::map<std::reply::type, std::function<handler()>> handlers_map{
{ std::reply::error, []() { return error_handler(); } },
/* etc. for each handle type */
};
handler handler_factor(const reply& r) {
return handlers_map.at(r.get_type())();
}
#if YAY_AN_ARRAY // an example of converting map to a static array
// TODO: do it as a member function
static handler error_handler_construct() { return error_handler(); }
static std::array<handler (*)(), 1> handlers_array{
&error_handler_construct,
/* etc. */
};
handler handler_factor(const reply &r) {
// remember about error handling
return handlers_array.at(
static_cast<int>(r.get_type())
)();
}
#elif YAY_ANOTHER_ARRAY
static handler (*const handlers_array[])() = {
[static_cast<int>(reply::type::error)] = &error_handler_construct,
/* etc. */
};
handler handler_factor(const reply &r) {
auto t = static_cast<int>(r.get_type();
if (t < 0 || t > sizeof(handlers_array)/sizeof(*handlers_array)) {
abort();
}
return handlers_array[t]();
}
#enidf
int main() {
reply rep;
auto h = handler_factor(rep);
h.handle(rep);
return 0;
}