#include "ClassDefs.hh"
#include <boost/python/class_builder.hpp>
#include <boost/python/cross_module.hpp>
namespace python = boost::python;

namespace {
  BOOST_PYTHON_MODULE_INIT(Second) {
    try {
      python::module_builder secondmodule("Second");

      // Import the two base classes from the Base module.
      python::import_converters<AbstractBase> AbstractBaseConverters("Base", "AbstractBase");
      python::import_converters<DefiniteBase> DefiniteBaseConverters("Base", "DefiniteBase");

      // Wrap DerivedClass
      python::class_builder<DerivedClass> DerivedClassBoost(secondmodule, "DerivedClass");
//       DerivedClassBoost.declare_base(AbstractBaseConverters); // This doesn't compile!
      DerivedClassBoost.def(python::constructor<>());

      // Wrap UseAbstractType
      python::class_builder<UseAbstractType> UseAbstractTypeBoost(secondmodule, "UseAbstractType");
      UseAbstractTypeBoost.def(python::constructor<AbstractBase&>());
      UseAbstractTypeBoost.def(&UseAbstractType::callPureMethod, "callPureMethod");

      // Wrap AnotherDerivedClass
      python::class_builder<AnotherDerivedClass> AnotherDerivedClassBoost(secondmodule, "AnotherDerivedClass");
      AnotherDerivedClassBoost.declare_base(DefiniteBaseConverters); // This doesn't compile!
      AnotherDerivedClassBoost.def(python::constructor<>());

      // Wrap UseDefiniteType
      python::class_builder<UseDefiniteType> UseDefiniteTypeBoost(secondmodule, "UseDefiniteType");
      UseDefiniteTypeBoost.def(python::constructor<DefiniteBase&>());
      UseDefiniteTypeBoost.def(&UseDefiniteType::callMethod, "callMethod");
    }

    catch(...) {
      python::handle_exception();
    }
  }
}