Move all base<->derived conversion stuff into ExtensionClassBase, where it belongs. Clean up some formatting.

[SVN r8002]

extclass.h

@@ -27,6 +27,7 @@ namespace py {
 
 // forward declarations
 class ExtensionInstance;
+class ExtensionClassBase;
 template <class T> class InstanceHolder;
 template <class T, class U> class InstanceValueHolder;
 template <class Ptr, class T> class InstancePtrHolder;
@@ -53,30 +54,39 @@ T* check_non_null(T* p)
 
 template <class T> class HeldInstance;
 
-namespace detail 
-{
+namespace detail {
+  typedef void* (*ConversionFunction)(void*);
 
-typedef void * (*ConversionFunction)(void *);
-
-struct BaseClassInfo
-{
-    typedef Class<ExtensionInstance> ClassObject;
+  struct BaseClassInfo
+  {
+      BaseClassInfo(ExtensionClassBase* t, ConversionFunction f)
+          :class_object(t), convert(f)
+          {}
     
-    BaseClassInfo(ClassObject * t, ConversionFunction f)
-    :class_object(t), convert(f)
-    {}
-    
-    ClassObject * class_object;
-    ConversionFunction convert;
-};
-typedef BaseClassInfo DerivedClassInfo;
+      ExtensionClassBase* class_object;
+      ConversionFunction convert;
+  };
 
+  typedef BaseClassInfo DerivedClassInfo;
 }
 
 class ExtensionClassBase : public Class<ExtensionInstance>
 {
  public:
     ExtensionClassBase(const char* name);
+    
+ public:
+    // the purpose of try_class_conversions() and its related functions 
+    // is explained in extclass.cpp
+    void* try_class_conversions(InstanceHolderBase*) const;
+    void* try_base_class_conversions(InstanceHolderBase*) const;
+    void* try_derived_class_conversions(InstanceHolderBase*) const;
+
+ private:
+    virtual void* extract_object_from_holder(InstanceHolderBase* v) const = 0;
+    virtual std::vector<py::detail::BaseClassInfo> const& base_classes() const = 0;
+    virtual std::vector<py::detail::DerivedClassInfo> const& derived_classes() const = 0;
+
  protected:
     void add_method(PyPtr<Function> method, const char* name);
     void add_default_method(PyPtr<Function> method, const char* name);
@@ -86,30 +96,28 @@ class ExtensionClassBase : public Class<ExtensionInstance>
     void add_constructor_object(Function*);
     void add_setter_method(Function*, const char* name);
     void add_getter_method(Function*, const char* name);
-    
-    // the purpose of try_class_conversions() and its related functions 
-    // is explained in extclass.cpp
-    virtual void * try_class_conversions(InstanceHolderBase*) const;
-    virtual void * try_base_class_conversions(InstanceHolderBase*) const;
-    virtual void * try_derived_class_conversions(InstanceHolderBase*) const;
-    virtual std::vector<py::detail::BaseClassInfo> const & base_classes() const = 0;
-    virtual std::vector<py::detail::DerivedClassInfo> const & derived_classes() const = 0;
 };
 
 template <class T>
 class ClassRegistry
 {
- public:    
-    static Class<ExtensionInstance>* class_object()
+ public:
+    static ExtensionClassBase* class_object()
         { return static_class_object; }
-    static void register_class(py::Class<py::ExtensionInstance>*);
-    static void unregister_class(py::Class<py::ExtensionInstance>*);
-    static void register_base_class(py::detail::BaseClassInfo const &);
-    static void register_derived_class(py::detail::DerivedClassInfo const &);
-    static std::vector<py::detail::BaseClassInfo> const & base_classes();
-    static std::vector<py::detail::DerivedClassInfo> const & derived_classes();
+
+    // Register/unregister the Python class object corresponding to T
+    static void register_class(ExtensionClassBase*);
+    static void unregister_class(ExtensionClassBase*);
+
+    // Establish C++ inheritance relationships
+    static void register_base_class(py::detail::BaseClassInfo const&);
+    static void register_derived_class(py::detail::DerivedClassInfo const&);
+
+    // Query the C++ inheritance relationships
+    static std::vector<py::detail::BaseClassInfo> const& base_classes();
+    static std::vector<py::detail::DerivedClassInfo> const& derived_classes();
  private:
-    static py::Class<py::ExtensionInstance>* static_class_object;
+    static ExtensionClassBase* static_class_object;
     static std::vector<py::detail::BaseClassInfo> static_base_class_info;
     static std::vector<py::detail::DerivedClassInfo> static_derived_class_info;
 };
@@ -438,15 +446,15 @@ class ExtensionClass
         ClassRegistry<S>::register_derived_class(derivedInfo);
     }
     
- private:
+ private: // types
     typedef InstanceValueHolder<T,U> Holder;
-    
-    virtual std::vector<detail::BaseClassInfo> const & base_classes() const;
-    virtual std::vector<detail::DerivedClassInfo> const & derived_classes() const;
 
-    // the purpose of this function is explained in extclass.cpp
-    virtual void * extract_object_from_holder(InstanceHolderBase * v) const;
+ private: // ExtensionClassBase virtual function implementations
+    std::vector<detail::BaseClassInfo> const& base_classes() const;
+    std::vector<detail::DerivedClassInfo> const& derived_classes() const;
+    void* extract_object_from_holder(InstanceHolderBase* v) const;
 
+ private: // Utility functions
     template <class Signature>
     void add_constructor(Signature sig)
     {
@@ -580,7 +588,7 @@ ExtensionClass<T, U>::derived_classes() const
 }
        
 template <class T, class U>
-void * ExtensionClass<T, U>::extract_object_from_holder(InstanceHolderBase * v) const
+void* ExtensionClass<T, U>::extract_object_from_holder(InstanceHolderBase* v) const
 {
     py::InstanceHolder<T>* held = dynamic_cast<py::InstanceHolder<T>*>(v);
     if(held) return held->target();
@@ -594,7 +602,7 @@ ExtensionClass<T, U>::~ExtensionClass()
 }
 
 template <class T>
-inline void ClassRegistry<T>::register_class(Class<ExtensionInstance>* p)
+inline void ClassRegistry<T>::register_class(ExtensionClassBase* p)
 {
     // You're not expected to create more than one of these!
     assert(static_class_object == 0);
@@ -602,7 +610,7 @@ inline void ClassRegistry<T>::register_class(Class<ExtensionInstance>* p)
 }
 
 template <class T>
-inline void ClassRegistry<T>::unregister_class(Class<ExtensionInstance>* p)
+inline void ClassRegistry<T>::unregister_class(ExtensionClassBase* p)
 {
     // The user should be destroying the same object they created.
     assert(static_class_object == p);
@@ -623,13 +631,13 @@ void ClassRegistry<T>::register_derived_class(py::detail::DerivedClassInfo const
 }
 
 template <class T>
-std::vector<py::detail::BaseClassInfo> const & ClassRegistry<T>::base_classes()
+std::vector<py::detail::BaseClassInfo> const& ClassRegistry<T>::base_classes()
 {
     return static_base_class_info;
 }
 
 template <class T>
-std::vector<py::detail::DerivedClassInfo> const & ClassRegistry<T>::derived_classes()
+std::vector<py::detail::DerivedClassInfo> const& ClassRegistry<T>::derived_classes()
 {
     return static_derived_class_info;
 }
@@ -638,7 +646,7 @@ std::vector<py::detail::DerivedClassInfo> const & ClassRegistry<T>::derived_clas
 // Static data member declaration.
 //
 template <class T>
-Class<py::ExtensionInstance>* ClassRegistry<T>::static_class_object;
+ExtensionClassBase* ClassRegistry<T>::static_class_object;
 template <class T>
 std::vector<py::detail::BaseClassInfo> ClassRegistry<T>::static_base_class_info;
 template <class T>