混合类型容器与单选原则

Question

I am pondering over my design of a picking mechanism for a 3D tool. In the tool, there are several pickable objects with different capabilities, meaning I have to differentiate between them for the UI (show different palettes etc. based on whatever the user has picked).

The picking mechanism is basically a container that knows all the objects in the document and can answer queries for the objects which are hit by a pick ray. It returns a list of hits, sorted by their distance to the camera. To register an object with the picker, it must implement the Pickable interface:

class Pickable {
    typedef enum {
        Entity,
        Brush,
        Patch
    } Type;

    virtual Type getType() const = 0;

    virtual const BBox3& getBounds() const = 0;

    // Returns the distance of the intersection point with the given ray
    // or NaN if this object doesn't intersect with the given ray.
    virtual double intersects(const Ray3& ray) const = 0;
};

The picker internally stores all objects in a spatial data structure (an octree) which of course only knows them as instances of Pickable . All the objects being hit by the pick ray are then wrapped in instances of Hit :

class Hit {
    double getDistance() const;
    const Vec3& getHitPoint() const;
    Pickable* getObject() const;
};

which are then added to a vector and sorted by distance. Now if I want to do something with the hit objects, I have to do something along the lines of

Hit hit = ... // obtain a hit from the picker
Pickable* object = hit.getObject();
switch (object->getType()) {
    case Pickable::Entity:
        // cast to Entity and perform some operation
        break;
    case Pickable::Brush:
        // cast to Brush and perform some operation
       break;
    ...
}

This of course violates the single choice principle . If I ever add a new object type, I have to touch all those switch statements which are strewn all over my codebase. For some operations that I want to apply to these objects, I can use a common super interface such as

class Object {
    virtual void transform(const Mat4x4& transformation);
    // other operations which are applicable to any type of object

    // I could even move some UI related functions into this interface:
    Palette* getUIPalette() const;
    void populateUIPalette(Palette* palette) const;
};

But there are some operations which can only be applied to entities, and some which can only be applied to brushes, and so on. The only solution I see is to move all operations into the Object interface, providing empty default implementations for operations which do not apply to all object types. But this also feels wrong as this would inflate the Object interface considerably.

My question is, are these the only two options or am I missing something? I really want to avoid casting and type checking as much as possible, but in this case, I don't see a good way around it.

Answer 1

You may use a Visitor Pattern :

Something like:

class IPickableVisitor;

class Pickable {
public:

    virtual void accept(IPickableVisitor& t);
};

class Entity : public Pickable {
public:
    void accept(IPickableVisitor& t) override { t.visit(*this); }
};

class Brush : public Pickable {
public:
    void accept(IPickableVisitor& t) override { t.visit(*this); }
};

class IPickableVisitor
{
public:
    virtual void visit(Entity& entity) = 0;
    virtual void visit(Brush& brush) = 0;
};

Now you may write:

class HitPickableVisitor : public IPickableVisitor
{
public:
    virtual void visit(Entity& entity) override
    {
        // Do the entity hit code.
    }
    virtual void visit(Brush& brush) override
    {
        // Do the brush hit code.
    }
};

And latter:

Pickable* object = hit.getObject();
HitPickableVisitor hitPickableVisitor;
object->accept(hitPickableVisitor);