Как реализовать более удобный для C ++ / OO-совместимый механизм диспетчеризации сетевых методов?

По крайней мере, одно возражение по этому вопросу приводит меня к выводу, что, по крайней мере, один человек может быть заинтересован в решении / ответе на этот вопрос.

Мне удалось удалить злые ключи и заменить их на то, что я маркирую как «отправленный вызов метода» или dmc в коде. Они отправляются при входе из сети для преобразования в вызовы методов, следовательно, из номенклатуры «отправленные вызовы методов»

Теперь иерархия использует функцию указателя на член, заключенную в адаптеры std :: function, которые являются типами значений std :: map:

typedef std::function<void(value_queue&)> dmcMethod;
typedef std::map<unsigned int,dmcMethod> call_map;

Веселье начинается в bvnet :: object (базовый класс), где карта вызовов инициализируется для ссылки на базовый класс dmc_GetType (функтор dmc для вызова переопределяемого GetType и отправки значения в очередь исходящих значений):

/**
** @brief ABC for remotable objects.
**
** Base used for objects exchangeable via object references.
**
** Since secure referencing requires a way to
** track object lifetime a registry reference
** is required for construction.
*/
typedef void(bvnet::object::*dmc)(value_queue&);
class object {
private:
/**
*   @brief Displateched Method Call
*
*   Implements dispatched method call (dmc)
*
*   Superclass-installed dmc methods in dmcTable are
*   callable by the remote.  A superclass sets up his
*   dmc methods in his ctor by accessing object's dmcTable
*
*   As a plus the lock and value queue boilerplate has been
*   been moved to the base class dispatcher and the dmc methods
*   will be in locked context and given the value queue as a
*   parameter.  He also has an exception now to trap calls to
*   an unimplemented method index.
*
*   @todo
*   some sort of static enum to get rid of the magic number
*   method call #s from remote POV?  I'll have the ctors store
*   method labels in the base class dmcName map while it is
*   setting up the dmc methods.
*
*   @todo
*   automatically declare the methods for method calling
*   via some sort of macro or metacode?
*
*/
friend class session;
void methodCall(unsigned int idx) {
bvnet::scoped_lock lock(ctx.getMutex());
bvnet::value_queue &vqueue=ctx.getSendQueue();
auto dmcFunc=dmcTable.find(idx);
if (dmcFunc!=dmcTable.end()) {
(dmcFunc->second)(this,vqueue);
} else {
// called a method that doesn't exist
throw method_notimpl(getType(),idx);
}
}
protected:
session &ctx;       /**< @brief for objects to attach to the session's registry */
call_map dmcTable;  /**< @brief method mapper for method call and OO mechanism */
name_map dmcLabel;  /**< @brief name labels of dmc methods */

void dmc_GetType(value_queue&); /**< @brief the GetType dispatched method call (dmc) */
private:
const string methodLabel(const unsigned int idx) {
const auto &s=dmcLabel.find(idx);
if (s!=dmcLabel.end()) {
return s->second;
}
return std::to_string(idx);
}
public:
/** @brief construction of an object @param sess reference to session to attach */
object(session &sess) :
ctx(sess) {
LOCK_COUT
cout << "object [" << this << "] ctor" << endl;
UNLOCK_COUT
ctx.register_object(this);
// dmtTable[0] is the GetType method
dmcTable[0]=&object::dmc_GetType;
dmcLabel[0]="GetType";
}
/** @brief base dtor to automatically unregister the object */
virtual ~object() {
LOCK_COUT
cout << "object [" << this << "] dtor" << endl;
UNLOCK_COUT
ctx.unregister(this);
}
/**
*   @brief Get object's identity.
*   @return Object identity string
*
*   Overriden by superclass to announce it's identity.
*/
virtual const char *getType() {return "baseObject";}
};

Это пример нового объекта serverRoot, когда-то модифицированного для использования механизма dmc (монолитный MethodCall и безумие переключателя исчезли):

class serverRoot : public bvnet::object {
private:
BigInt cli_pub_mod;
BigInt cli_pub_exp;
Key *clientKey;
bool clientValid;
string challenge;
SQLiteDB db;
unsigned int randbits[8];
protected:
void dmc_LoginClient(value_queue &vqueue);
void dmc_AnswerChallenge(value_queue &vqueue);
void dmc_GetAccount(value_queue &vqueue);
public:
serverRoot(bvnet::session &sess)
: bvnet::object(sess) {
dmcLabel[1]="LoginClient";
dmcTable[1]=(dmc)&serverRoot::dmc_LoginClient;
dmcLabel[2]="AnswerChallenge";
dmcTable[2]=(dmc)&serverRoot::dmc_AnswerChallenge;
dmcLabel[3]="GetAccount";
dmcTable[3]=(dmc)&serverRoot::dmc_GetAccount;
clientValid=false;
challenge="";
clientKey=NULL;
}
virtual ~serverRoot() {
if (clientKey!=NULL)
delete clientKey;
}

virtual const char *getType() {return "serverRoot";}

};

Здесь важно отметить, что MethodCall больше не существует внутри serverRoot (или Account, clientRoot и последующих друзей), и что он должен что-то делать с dmcLabel [0] / dmcTabel [0] — он наследует настройки от bvnet: : Объектный ctor. Точно так же, если бы futureServerRoot создавал подкласс serverRoot, он бы унаследовал таблицу dmc от обоих cvnet :: Object и serverRoot. Таким образом, у меня теперь есть надлежащий механизм наследования в иерархии dmc, и нет электронной почты с ядерной бомбой от будущего сопровождающего (ну, в любом случае, по этой причине), пытающегося сделать класс futureServerRoot: public serverRoot;)

В целом полезный рефакторинг. Это исключило кучу котельной плиты (которая не понадобится и на последующих объектах). Шаблон dmc является менее громоздким в классах (реализации могут быть перемещены из встроенных классов или иным образом) и больше не застревает в злом монолитном переключении из ада.

Не идеально, но это большое улучшение по сравнению с тем, что у меня было раньше, и оно дает ответ на мой первоначальный вопрос.