PIParseHelper< Key > Class Template Reference

Maps packet keys to handlers and deserializes payloads before invocation. More...

#include <piparsehelper.h>

Public Member Functions
	PIParseHelper ()
	Constructs empty parser helper.
void	assign (Key key, std::function< void()> func)
	Assigns key "key" to callback "func" without payload arguments.
template<typename T>
void	assign (Key key, std::function< void(const T &)> func)
	Assigns key "key" to callback "func" with one deserialized argument.
template<typename O>
void	assign (Key key, O *obj, void(O::*member_func)())
	Assigns key "key" to zero-argument member function of object "obj".
template<typename T, typename O>
void	assign (Key key, O *obj, void(O::*member_func)(const T &))
	Assigns key "key" to member function of object "obj" with one deserialized argument.
template<typename L>
void	assign (Key key, L func)
	Assigns key "key" to functor or lambda with zero or one argument.
void	parse (Key key, PIByteArray ba)
	Deserializes payload "ba" and invokes handlers assigned to "key".

Detailed Description

template<typename Key>
class PIParseHelper< Key >

Maps packet keys to handlers and deserializes payloads before invocation.

PIParseHelper helps replace manual switch-based packet dispatch with a set of assign() calls. Handlers may be plain callbacks, functors or object member functions. Payload types are restored from PIByteArray by the selected handler signature.

Example:

enum Header {
    hInt = 1,
    hString,
    hVoid
};
 
class MyObj
    : public PIObject
    , public PIParseHelper<uchar> {
    PIOBJECT(MyObj);
 
public:
    MyObj(): PIParseHelper<uchar>(this) {
        // Keys with 1 argument
        assign(hInt, std::function<void(int)>([this](int i) { piCout << "lambda type Int" << i; }));
        assign(hInt, HANDLER(methodI));
        assign(hString, HANDLER(methodS));
 
        // hVoid key, without arguments
        assign(hVoid, []() { piCout << "type void"; });
        assign(hVoid, HANDLER(method));
    }
    EVENT_HANDLER1(void, methodI, int, i) { piCout << "methodI" << i; }
    EVENT_HANDLER1(void, methodS, PIString, s) { piCout << "methodS" << s; }
    EVENT_HANDLER0(void, method) { piCout << "method"; }
};
 
int main() {
    MyObj o;
 
    PIByteArray data;
 
    data.clear();
    data << 11;
    o.parse(hInt, data);
    // lambda type Int 11
    // methodI 11
 
    data.clear();
    data << PIString("text");
    o.parse(hString, data);
    // methodS text
 
    data.clear();
    o.parse(hVoid, data);
    // type void
    // method
}

enum Header {
    hInt = 1,
    hString,
    hVoid
};
 
class MyObj: public PIObject {
    PIOBJECT(MyObj);
 
public:
    EVENT_HANDLER1(void, methodI, int, i) { piCout << "methodI" << i; }
    EVENT_HANDLER1(void, methodS, PIString, s) { piCout << "methodS" << s; }
    EVENT_HANDLER0(void, method) { piCout << "method"; }
};
 
int main() {
    MyObj obj;
    PIParseHelper<int> parser(&obj);
 
    parser.assign(hInt, obj.HANDLER(methodI));
    parser.assign(hString, obj.HANDLER(methodS));
    parser.assign(hVoid, obj.HANDLER(method));
 
    PIByteArray data;
 
    data.clear();
    data << 11;
    parser.parse(hInt, data);
    // methodI 11
 
    data.clear();
    data << PIString("text");
    parser.parse(hString, data);
    // methodS text
 
    data.clear();
    parser.parse(hVoid, data);
    // method
}