Administrace komentářů

Řeším takový návrhový problém a hledám elegantní řešení v C++.

Obecně jde o to, že mám třídu (např. parser), jejíž instance přijímá události (někdo volá její metody), nějak je zpracovává a výsledky předává dál – volá metody jiného objektu (handler). Těch handlerů může být víc, implementují stejné rozhraní a uživatel je registruje před začátkem zpracování pomocí metody addHandler().

Napadá mě několik možností:

• Metoda addHandler() přidá handler do kolekce a pak budu místo handler->metoda() volat for (auto handler : handlers) handler->metoda() a tím se událost rozešle všem.
• Metoda addHandler() nebude v parseru a parser bude sám schopný pracovat jen s jedním handlerem. Pokud jich bude potřeba víc, vytvoří se proxy handler, který bude implementovat stejné rozhraní a postará se o rozeslání všem stejným způsobem jako v předchozím bodě.
• Makra a/nebo šablony, které usnadní zápis výše popsaných řešení.
• Generátor kódu, který bude mít na vstupu definici rozhraní a na výstupu proxy handler.

Ten handler může mít třeba deset metod, takže se mi to úplně nechce psát všechno ručně, navíc tenhle problém budu asi řešit opakovaně. Časem bych možná chtěl nějak lépe ošetřovat chyby (např. když by jeden handler vyhazoval výjimku, tak aby zpracování dat v ostatních pokračovalo dál a chyba se nějak zpracovala až na konci), ale pro začátek to může být tak, že první vyhozená výjimka zastaví všechno a zpracování skončí.

Přijde mi, že tohle musí být docela obvyklá úloha, snad i návrhový vzor nebo idiom… tak se mi nechce vynalézat kolo. Jak tohle řešíte vy?

P.S. To řešení pomocí maker může vypadat takhle:

#define handler for (auto ___h : handlers) ___h

handler->metoda0();
handler->metoda1(a, b);
handler->metoda2(a, b, c);
...
handler->metoda9(x);

Což tak nějak s minimem úsilí řeší tenhle problém, ale moc nadšený z toho nejsem.

P.P.S. Případně takhle může vypadat kombinace toho makra a proxy:

class XYZContentHandler {
public:

	virtual void abc();
	virtual void def(int a);
	virtual void ghi(int a, int b);

};

class XYZContentHandlerProxy : public XYZContentHandler {
private:
	std::vector<std::shared_ptr<XYZContentHandler>> handlers;
public:

	void addHandler(std::shared_ptr<XYZContentHandler> handler) {
		handlers.push_back(handler);
	}

#define handler for (auto ___h : handlers) ___h

	void abc() override { handler->abc(); }
	void def(int a) override { handler->def(a); }
	void ghi(int a, int b) override { handler->ghi(a,b); }

#undef handler

};

Ale nejradši bych se zbavil toho ručně psaného kódu (proxy) a řešil to nějak obecně, genericky.