Good design when polymorphism isn't possible

Question

I am developing a visual editor for an entity component system. The editor must be able to modify the members of differents components subtypes, so we have a specific window for each component subtype.

The problem is we can't modify the components to implement a polymorphic method to display the correct window since it's a extern library. So what would be a appropriate design to avoid this:

void edit(Component component) {
    if (component instanceOf Position) {
       new PositionEditorWindow((Position) component).display();
    } else if (component instanceOf Velocity) {
       new VelocityEditorWindow((Velocity) component).display();
    } else if ...
}

(Separate comment: if we can modify the components, does it makes any sense to add a polymorphic method with editor logic to a component? I was thinking a visitor has more sense)

Answer 1

The problem is we can't modify the components to implement a polymorphic method to display the correct window since it's a extern library.

You may not be able to modify the component, but you can almost certainly compose them to produce the same effect. Pseudo code, adapt to your favourite language:

interface IComponent
{
  void display();
}

class PositionComponent : IComponent
{
  private Position _p;

  PositionComponent(Position p) { _p = p; }

  void display()
  {
    new PositionEditorWindow(_p).display();
  }
}

class VelocityComponent : IComponent
{
  private Velocity _v;

  VelocityComponent(Velocity v) { _v = v; }

  void display()
  {
    new VelocityEditorWindow(_v).display();
  }
}

and your edit function can now just call display on an IComponent.

This is of course an example of the facade pattern:

Provide a unified interface to a set of interfaces in a subsystem. Facade defines a higher-level interface that makes the subsystem easier to use. This can be used to simplify a number of complicated object interactions into a single interface.

and yes, you absolutely can/should add more functionality to the facade to represent the other actions that components can perform.