// Copyright David Abrahams 2003.

 // Distributed under the Boost Software License, Version 1.0. (See

 // accompanying file LICENSE_1_0.txt or copy at

 // http://www.boost.org/LICENSE_1_0.txt)

 #ifndef PURE_VIRTUAL_DWA2003810_HPP

 # define PURE_VIRTUAL_DWA2003810_HPP

 # include <boost/python/def_visitor.hpp>

 # include <boost/python/default_call_policies.hpp>

 # include <boost/mpl/push_front.hpp>

 # include <boost/mpl/pop_front.hpp>

 # include <boost/python/detail/nullary_function_adaptor.hpp>

 namespace boost { namespace python { 

 namespace detail

 {

   //

   // @group Helpers for pure_virtual_visitor. {

   //

   // Raises a Python RuntimeError reporting that a pure virtual

   // function was called.

   void BOOST_PYTHON_DECL pure_virtual_called();

   // Replace the two front elements of S with T1 and T2

   template <class S, class T1, class T2>

   struct replace_front2

   {

       // Metafunction forwarding seemed to confound vc6 

       typedef typename mpl::push_front<

           typename mpl::push_front<

               typename mpl::pop_front<

                   typename mpl::pop_front<

                       S

                   >::type

               >::type

             , T2

           >::type

         , T1

       >::type type;

   };

   // Given an MPL sequence representing a member function [object]

   // signature, returns a new MPL sequence whose return type is

   // replaced by void, and whose first argument is replaced by C&.

   template <class C, class S>

   typename replace_front2<S,void,C&>::type

   error_signature(S BOOST_APPEND_EXPLICIT_TEMPLATE_TYPE(C))

   {

       typedef typename replace_front2<S,void,C&>::type r;

       return r();

   }

   //

   // } 

   //

   //

   // A def_visitor which defines a method as usual, then adds a

   // corresponding function which raises a "pure virtual called"

   // exception unless it's been overridden.

   //

   template <class PointerToMemberFunction>

   struct pure_virtual_visitor

     : def_visitor<pure_virtual_visitor<PointerToMemberFunction> >

   {

       pure_virtual_visitor(PointerToMemberFunction pmf)

         : m_pmf(pmf)

       {}

    private:

       friend class python::def_visitor_access;

       template <class C_, class Options>

       void visit(C_& c, char const* name, Options& options) const

       {

           // This should probably be a nicer error message

           BOOST_STATIC_ASSERT(!Options::has_default_implementation);

           // Add the virtual function dispatcher

           c.def(

               name

             , m_pmf

             , options.doc()

             , options.keywords()

             , options.policies()

           );

           typedef BOOST_DEDUCED_TYPENAME C_::metadata::held_type held_type;

           // Add the default implementation which raises the exception

           c.def(

               name

             , make_function(

                   detail::nullary_function_adaptor<void(*)()>(pure_virtual_called)

                 , default_call_policies()

                 , detail::error_signature<held_type>(detail::get_signature(m_pmf))

               )

           );

       }

    private: // data members

       PointerToMemberFunction m_pmf;

   };

 }

 //

 // Passed a pointer to member function, generates a def_visitor which

 // creates a method that only dispatches to Python if the function has

 // been overridden, either in C++ or in Python, raising a "pure

 // virtual called" exception otherwise.

 //

 template <class PointerToMemberFunction>

 detail::pure_virtual_visitor<PointerToMemberFunction>

 pure_virtual(PointerToMemberFunction pmf)

 {

     return detail::pure_virtual_visitor<PointerToMemberFunction>(pmf);

 }

 }} // namespace boost::python

 #endif // PURE_VIRTUAL_DWA2003810_HPP