#include <Core/Core.h>
using namespace Upp;

class Element
{
//some base class interface	
};

class ElementA : public Element
{
//some concrete implementation of Element
};

class ElementB : public Element
{
//another concrete implementation of Element
};

// the above classes dont mustn't know anything of the following classes

class ElementEditor
{
// generic Element editing
};

class ElementAEditor : public ElementEditor
{
// specific/additional ElementA editing
};

class ElementBEditor : public ElementEditor
{
// specific/additional ElementB editing
};

//

void EditElement(const Element& e)
{
	//how to dynamicly dispatch to the right Element Editor? truely, depending on runtime type of Element?

	//cant use Visitor pattern (implies extending Element with a Visitor interface, which knows of all Editors, Bad!!!)
	//cant use Strategy pattern (implies extending Element with additional hook to invoke a pluged in editor, is more or less a cache of a once chosen editor dispatching)
	
	//is dynamic_cast<> option the only one possible? 
	
	if(ElementA* p = dynamic_cast<ElementA*>(&e)) { /*invoke ElementAEditor*/ }
	else
	if(ElementB* p = dynamic_cast<ElementB*>(&e)) { /*invoke ElementBEditor*/ }
	else { /* invoke ElementEditor as fallback */ }
}