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

namespace {
  BOOST_PYTHON_MODULE_INIT(Base) {
    try {
      python::module_builder basemodule("Base");

      // Wrap AbstractBase
      python::class_builder<AbstractBase> AbstractBaseBoost(basemodule, "AbstractBase");
      AbstractBaseBoost.def(&AbstractBase::pureMethod, "pureMethod");
      // Want to export the type for use by other modules, but can't!!
      python::export_converters(AbstractBaseBoost);

      // Wrap DerivedClass
      python::class_builder<DerivedClass> DerivedClassBoost(basemodule, "DerivedClass");
      DerivedClassBoost.declare_base(AbstractBaseBoost);
      DerivedClassBoost.def(python::constructor<>());

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

      // Wrap DefiniteBase
      python::class_builder<DefiniteBase> DefiniteBaseBoost(basemodule, "DefiniteBase");
      DefiniteBaseBoost.def(&DefiniteBase::method, "method");
      python::export_converters(DefiniteBaseBoost);

      // Wrap AnotherDerivedClass
      python::class_builder<AnotherDerivedClass> AnotherDerivedClassBoost(basemodule, "AnotherDerivedClass");
      AnotherDerivedClassBoost.declare_base(DefiniteBaseBoost);
      AnotherDerivedClassBoost.def(python::constructor<>());

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

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