Re: Multimethods idioms and library support

On 22 Feb., itaj sherman wrote:


There is no possible way that Double Dispatch could work without some
entity knowing all sub-classes that are involved in Double Dispatch.
The way I have shown is probably far from perfect, but it shows that
this problem can be solved by C++ without resorting to dynamic_casts.


Well, if two users A and B add different objects, someone has to
figure what should happen if objects from user A meet objects of user
B.

SCNR:
#include <iostream>

// We want to be able to dynamically dispatch three different
// base classes, Prey, Carnivour, and Location, with n
// sub-classes. Since Double Dispatch uses vtables, we have to
// have a class with n^2 entries in its vtable. This class contains
// the actual algorithmic part (in our scenario this class will
// be the Carnivour class).
// To be able to implement Double Dispatch, we have to stuff
// one additional class with a vtable of n entries (Location).

///////////////////////////////////////////////////////////

class CarnivourDispatch;
class Location;

class Prey
{
public:
  virtual void dispatchMe (CarnivourDispatch*,Location&) = 0;
};

///////////////////////////////////////////////////////////

class Location;

class Carnivour
{
public:
  virtual void hunt (Prey& prey, Location& location) = 0;
};

///////////////////////////////////////////////////////////

// CarnivourDispatch needs to know all derived classes, both
// prey and locations.
class Plains;
class Ocean;
class Gazelle;
class Giraffe;
class Gnu;

class CarnivourDispatch : public Carnivour
{
public:
  // This starts the double dispatch.
  virtual void hunt (Prey& prey, Location& location)
  {
    prey.dispatchMe (this, location);
  }
  virtual void huntPreyLocation (Gazelle&, Plains&) = 0;
  virtual void huntPreyLocation (Giraffe&, Plains&) = 0;
  virtual void huntPreyLocation (Gnu&, Plains&) = 0;
  virtual void huntPreyLocation (Gazelle&, Ocean&) = 0;
  virtual void huntPreyLocation (Giraffe&, Ocean&) = 0;
  virtual void huntPreyLocation (Gnu&, Ocean&) = 0;
};

///////////////////////////////////////////////////////////

template<class t_ImplementationClass>
class PreyDispatchHelper : public Prey
{
public:
  void dispatchMe (CarnivourDispatch* Hunter, Location& location)
  {
    location.dispatchMe (Hunter, *static_cast<t_ImplementationClass*>
(this));
  }
};

class Giraffe : public PreyDispatchHelper<Giraffe>
{
};

class Gazelle : public PreyDispatchHelper<Gazelle>
{
};

class Gnu : public PreyDispatchHelper<Gnu>
{
};

//////////////////////////////////////////////////////////////////////////
// We need to know all derived classes of Prey at compile-time.

// Forward declaration of all Prey-derived classes.
class Gazelle;
class Giraffe;
class Gnu;

template<class t_Base1, class t_Base2>
class TMultipleInheritance : public t_Base1, public t_Base2
{
public:
  typedef t_Base1 TBase1;
  typedef t_Base2 TBase2;
};

class NullPrey
{};

class PreyEnum : public TMultipleInheritance
                        <
                          Gnu,
                          TMultipleInheritance
                          <
                            Giraffe,
                            TMultipleInheritance
                            <
                              Gazelle, NullPrey
                            >
                          >
                        >
{
};

// LocationHelper2 adds the virtual methods
// virtual void dispatchMe (CarnivourDispatch*, Gazelle&) = 0;
// virtual void dispatchMe (CarnivourDispatch*, Gnu&) = 0;
// and so on to the Location interface.
template<class t_DummyArgument = int, class t_PreyEnum = PreyEnum>
class LocationHelper2 : public LocationHelper2<t_DummyArgument,
typename t_PreyEnum::TBase2>
{
public:
  typedef LocationHelper2<t_DummyArgument, typename
t_PreyEnum::TBase2> TBaseLocationHelper2;
  using TBaseLocationHelper2::dispatchMe;
  virtual void dispatchMe (CarnivourDispatch* Hunter,typename
t_PreyEnum::TBase1& prey) = 0;
};

template<class t_DummyArgument>
class LocationHelper2<t_DummyArgument, NullPrey>
{
public:
  typedef NullPrey TBaseLocationHelper2;

  // We need this as base for the using-declaration in the
  // non-specialized template.
  void dispatchMe (){}
};

// We could as well drop this class, but it makes forward
// declarations much easier.
class Location : public LocationHelper2<>
{
};

////////////////////////////////////////////////////////////
// Implementation helper of the virtual methods of Location
template<class t_ImplemenationClass, class t_PreyEnum = PreyEnum>
class LocationDispatchHelper2 : public
LocationDispatchHelper2<t_ImplemenationClass, typename
t_PreyEnum::TBase2>
{
protected:
  typedef LocationDispatchHelper2<t_ImplemenationClass, typename
t_PreyEnum::TBase2> TBaseLocationDispatchHelper2;
public:
  using TBaseLocationDispatchHelper2::dispatchMe;
  virtual void dispatchMe (CarnivourDispatch* Hunter,typename
t_PreyEnum::TBase1& prey)
  {
    Hunter->huntPreyLocation (prey,
*static_cast<t_ImplemenationClass*> (this));
  }
};

template<class t_ImplemenationClass>
class LocationDispatchHelper2<t_ImplemenationClass, NullPrey> : public
Location
{
protected:
  typedef Location TBaseLocationDispatchHelper2;
};

// Now we can easily add our locations.
class Plains : public LocationDispatchHelper2<Plains>
{
};

class Ocean : public LocationDispatchHelper2<Ocean>
{
};

class Lion: public CarnivourDispatch
{
protected:
  virtual void huntPreyLocation (Gazelle& gazelle, Plains& plains)
  {
    std::cout << "Lion jumps on gazelle and bites its neck in the
plains." << std::endl;
  }

  virtual void huntPreyLocation (Giraffe& giraffe, Plains& plains)
  {
    std::cout << "Lion bites giraffe's ass in the plains" <<
std::endl;
  }

  virtual void huntPreyLocation (Gnu& gnu, Plains& plains)
  {
    std::cout << "Lion rides gnu to death in the plains" << std::endl;
  }

  virtual void huntPreyLocation (Gazelle&, Ocean&)
  {
    std::cout << "Lion cooks gazelle in Pacific Ocean." << std::endl;
  }
  virtual void huntPreyLocation (Giraffe&, Ocean&)
  {
    std::cout << "Lion runs over giraffe with jet skies." <<
std::endl;
  }

  virtual void huntPreyLocation (Gnu&, Ocean&)
  {
    std::cout << "Lion launches torpedo at gnu." << std::endl;
  }
};

//main.cpp
int main()
{
  Carnivour* carnivour = new Lion;
  Location* location = new Plains;
  Location* location2 = new Ocean;
  Prey* prey1 = new Gazelle;
  Prey* prey2 = new Giraffe;
  Prey* prey3 = new Gnu;
  carnivour->hunt (*prey1, *location);
  carnivour->hunt (*prey2, *location);
  carnivour->hunt (*prey3, *location);
  carnivour->hunt (*prey1, *location2);
  carnivour->hunt (*prey2, *location2);
  carnivour->hunt (*prey3, *location2);

  return 0;
}

Regards,
Stuart