Re: Multimethods idioms and library support

This is a multi-part message in MIME format.
--------------050608070803040303030601
Content-Type: text/plain; charset=ISO-8859-1
Content-Transfer-Encoding: 7bit

On 02/22/11 22:36, Larry Evans wrote:


One solution is to define a new metafunction in reifier_visitor.hpp:

  template
  < typename HostConcrete
  >
struct host_abstract
  /**@brief
   * Metafunction returning Abstract class
   * of which HostConcrete is a member.
   * IOW, does inverse of hosts_concrete.
   */
{
        typedef
      HostConcrete
    type
    //By default, HostConcrete is member
    //of a type hierarchy starting at
    //HostConcrete.
    ;
};

and them modify the argument, HeadAbstract, to hosts_concrete to
super of reifier_visitor by host_abstract<HeadAbstract>::type.
That converts any concrete type back to its abstract super.
Of course that's less than ideal because it requires
specializations of host_abstract to map all the derived classes
back to their abstract classes and causes mover virtual
function calls to undo what was just done by host_abstract.

Will upload the modified reifier_visitor.hpp to sandbox.
The modified driver, with all the host_abstract specializations,
is attached.

-Larry

--------------050608070803040303030601
Content-Type: text/x-c++src;
 name="predator_prey.cpp"
Content-Transfer-Encoding: 7bit
Content-Disposition: attachment;
 filename="predator_prey.cpp"

//Purpose:
// See if code from the following post works.
/*
From: itaj sherman <itajsherman@gmail.com>
Newsgroups: comp.lang.c++
Subject: Re: Multimethods idioms and library support
Date: Tue, 22 Feb 2011 13:23:05 -0800 (PST)
Organization: http://groups.google.com
Lines: 105
Message-ID: <3f848282-d123-408d-8d25-de12b0f2eca7@u6g2000vbh.googlegroups.com>
 */
//
#include <boost/composite_storage/pack/multiple_dispatch/reify_apply.hpp>
#include <boost/composite_storage/pack/multiple_dispatch/reifier_visitor.hpp>
#include <iostream>

namespace boost
{
namespace composite_storage
{
namespace pack
{
namespace multiple_dispatch
{
namespace testing
{

typedef void ResultType;

//Predators:
  struct Lion;
  struct Anaconda;
  struct Bear;

struct Predator_abstract;
}//exit testing namespace

template<>
struct hosts_concrete
  < testing::Predator_abstract
  >
  : mpl::package
    < testing::Lion
    , testing::Bear
    , testing::Anaconda
    >
{
};

template<>
struct host_abstract
  < testing::Lion
  >
{
      typedef
    testing::Predator_abstract
  type
  ;
};

template<>
struct host_abstract
  < testing::Bear
  >
{
      typedef
    testing::Predator_abstract
  type
  ;
};

template<>
struct host_abstract
  < testing::Anaconda
  >
{
      typedef
    testing::Predator_abstract
  type
  ;
};

namespace testing
{

struct Predator_abstract
{
  typedef reifier_visit_abstract_seq< ResultType
    , hosts_concrete<Predator_abstract>::type>
  visitor_abstract;

  virtual ResultType accept( visitor_abstract const&)const=0;
};

struct Lion: public Predator_abstract
{
  ResultType accept( visitor_abstract const& a_visitor)const
  {
    return a_visitor.visit(*this);
  }
};

struct Anaconda: public Predator_abstract
{
  ResultType accept( visitor_abstract const& a_visitor)const
  {
    return a_visitor.visit(*this);
  }
};

struct Bear: public Predator_abstract
{
  ResultType accept( visitor_abstract const& a_visitor)const
  {
    return a_visitor.visit(*this);
  }
};

//Preys:
  struct Gazelle;
  struct Girrafe;
  
struct Prey_abstract;
}//exit namespace testing

template<>
struct hosts_concrete
  < testing::Prey_abstract
  >
  : mpl::package
    < testing::Gazelle
    , testing::Girrafe
    >
{
};

template<>
struct host_abstract
  < testing::Gazelle
  >
{
      typedef
    testing::Prey_abstract
  type
  ;
};

template<>
struct host_abstract
  < testing::Girrafe
  >
{
      typedef
    testing::Prey_abstract
  type
  ;
};

namespace testing
{

struct Prey_abstract
{
  typedef reifier_visit_abstract_seq< ResultType
    , hosts_concrete<Prey_abstract>::type>
  visitor_abstract;

  virtual ResultType accept( visitor_abstract const&)const=0;
};

struct Gazelle: public Prey_abstract
{
  ResultType accept( visitor_abstract const& a_visitor)const
  {
    return a_visitor.visit(*this);
  }
};

struct Girrafe: public Prey_abstract
{
  ResultType accept( visitor_abstract const& a_visitor)const
  {
    return a_visitor.visit(*this);
  }
};

  template<typename Animal>
struct animal_name
;
  template<>
struct animal_name<Gazelle>
{
    static std::string _(){ return "Gazelle";}
};
  template<>
struct animal_name<Girrafe>
{
    static std::string _(){ return "Girrafe";}
};

struct hunt_functor
{

  typedef ResultType result_type;

  void operator()( Lion const&, Gazelle const& )
  {
    std::cout<<"Lion jumps on Gazelle and bites its neck.\n";
  }

  void operator()( Lion const&, Girrafe const& )
  {
    std::cout<<"Lion jumps on Girrafe and bites its ass.\n";
  }

  void operator()( Anaconda const&, Gazelle const& )
  {
    std::cout<<"Anaconda injects venom into Gazelle.\n";
  }

  void operator()( Anaconda const&, Girrafe const& )
  {
    std::cout<<"Anaconda ignores Girraffe.\n";
  }

  //Anaconda can't kill girrafes so no override for that one

  template<typename PreyConcrete>
  void operator()( Bear const&, PreyConcrete const& )
  {
    std::cout<<"Bear mauls "<<animal_name<PreyConcrete>::_()<<"\n";

  }

};

void test()
{
    hunt_functor hunter;
    Lion lion;
    Girrafe girrafe;
  #if 0
    Predator_abstract&pred1=lion;
    Prey_abstract&prey1=girrafe;
    reify_apply<reifier_visitor>(hunter, pred1, prey1);
  #else
    reify_apply<reifier_visitor>(hunter, lion, girrafe);
  #endif
}

}//exit testing namespace
}//exit multiple_dispatch namespace
}//exit pack namespace
}//exit composite_storage namespace
}//exit boost namespace

int main(void)
{
    boost::composite_storage::pack::multiple_dispatch::testing::test();
    return 0;
}

--------------050608070803040303030601--