changes according to Dave's code review (coding conventions, moving functions around etc.)

[SVN r7978]
2026-01-22 05:22:45 +00:00 · 2000-10-17 20:05:26 +00:00
parent ab5f450e45
commit dc3b9c510d
5 changed files with 92 additions and 62 deletions
--- a/class_wrapper.h
+++ b/class_wrapper.h
@@ -66,37 +66,45 @@ class ClassWrapper
    void def_read_write(MemberType T::*pm, const char* name)
        { m_class->def_read_write(pm, name); }
        
-    // declare the given class a base class of this and register 
+    // declare the given class a base class of this one and register 
    // conversion functions
    template <class S, class V>
    void declare_base(ClassWrapper<S, V> const & base)
    {
-        m_class->declare_base(base.m_class.get());
+        m_class->declare_base(base.get_extension_class());
    }

-    // declare the given class a base class of this and register 
-    // conversion functions
+    // declare the given class a base class of this one and register 
+    // upcast conversion function
    template <class S, class V>
    void declare_base(ClassWrapper<S, V> const & base, WithoutDowncast)
    {
-        m_class->declare_base(base.m_class.get(), without_downcast);
+        m_class->declare_base(base.get_extension_class(), without_downcast);
    }

+    // declare the given class a base class of this one and register 
+    // conversion functions
    template <class S, class V>
    void declare_base(ExtensionClass<S, V> * base)
    {
        m_class->declare_base(base);
    }
        
-    // declare the given class a base class of this and register 
-    // only upcast function
+    // declare the given class a base class of this one and register 
+    // upcast conversion function
    template <class S, class V>
    void declare_base(ExtensionClass<S, V> * base, WithoutDowncast)
    {
        m_class->declare_base(base, without_downcast);
    }
    
-// private:
+    // get the embedded ExtensioClass object
+    ExtensionClass<T, U> * get_extension_class() const 
+    {
+        return m_class.get();
+    }
+    
+ private:
    PyPtr<ExtensionClass<T, U> > m_class;
 };

--- a/extclass.cpp
+++ b/extclass.cpp
@@ -220,35 +220,41 @@ ExtensionClassBase::ExtensionClassBase(const char* name)

 void * ExtensionClassBase::try_class_conversions(InstanceHolderBase * object) const
 {
-    void * result = try_subclass_conversions(object);
-    if(result) return result;
-    result = try_superclass_conversions(object);
+    void * result = try_derived_class_conversions(object);
+    if(result) 
+        return result;
+    result = try_base_class_conversions(object);
    return result;
 }

-void * ExtensionClassBase::try_superclass_conversions(InstanceHolderBase * object) const
+void * ExtensionClassBase::try_base_class_conversions(InstanceHolderBase * object) const
 {
    void * result = 0;
    for(int i=0; i<base_classes().size(); ++i)
    {
-        if(base_classes()[i].convert == 0) continue;
+        if(base_classes()[i].convert == 0) 
+            continue;
        result = base_classes()[i].class_object->convert_from_holder(object);
-        if(result) return (*base_classes()[i].convert)(result);
-        result = base_classes()[i].class_object->try_superclass_conversions(object);
-        if(result) return (*base_classes()[i].convert)(result);
+        if(result) 
+            return (*base_classes()[i].convert)(result);
+        result = base_classes()[i].class_object->try_base_class_conversions(object);
+        if(result) 
+            return (*base_classes()[i].convert)(result);
    }
    return 0;
 }

-void * ExtensionClassBase::try_subclass_conversions(InstanceHolderBase * object) const
+void * ExtensionClassBase::try_derived_class_conversions(InstanceHolderBase * object) const
 {
    void * result = 0;
-    for(int i=0; i<sub_classes().size(); ++i)
+    for(int i=0; i<derived_classes().size(); ++i)
    {
-        result = sub_classes()[i].class_object->convert_from_holder(object);
-        if(result) return (*sub_classes()[i].convert)(result);
-        result = sub_classes()[i].class_object->try_subclass_conversions(object);
-        if(result) return (*sub_classes()[i].convert)(result);
+        result = derived_classes()[i].class_object->convert_from_holder(object);
+        if(result) 
+            return (*derived_classes()[i].convert)(result);
+        result = derived_classes()[i].class_object->try_derived_class_conversions(object);
+        if(result) 
+            return (*derived_classes()[i].convert)(result);
    }
    return 0;
 }
--- a/extclass.h
+++ b/extclass.h
@@ -52,18 +52,24 @@ T* check_non_null(T* p)
 }

 template <class T> class HeldInstance;
-typedef void * (*ConversionFct)(void *);
+
+namespace detail 
+{
+
+typedef void * (*ConversionFunction)(void *);

 struct BaseClassInfo
 {
-    BaseClassInfo(TypeObjectBase * t, ConversionFct f)
+    BaseClassInfo(Class<ExtensionInstance> * t, ConversionFunction f)
    :class_object(t), convert(f)
    {}
    
-    TypeObjectBase *class_object;
-    ConversionFct convert;
+    Class<ExtensionInstance> * class_object;
+    ConversionFunction convert;
 };
-typedef BaseClassInfo SubClassInfo;
+typedef BaseClassInfo DerivedClassInfo;
+
+}

 class ExtensionClassBase : public Class<ExtensionInstance>
 {
@@ -80,10 +86,10 @@ class ExtensionClassBase : public Class<ExtensionInstance>
    void add_getter_method(Function*, const char* name);
    
    virtual void * try_class_conversions(InstanceHolderBase*) const;
-    virtual void * try_superclass_conversions(InstanceHolderBase*) const;
-    virtual void * try_subclass_conversions(InstanceHolderBase*) const;
-    virtual std::vector<BaseClassInfo> const & base_classes() const = 0;
-    virtual std::vector<SubClassInfo> const & sub_classes() const = 0;
+    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>
@@ -94,14 +100,14 @@ class ClassRegistry
        { 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(BaseClassInfo const &);
-    static void register_sub_class(SubClassInfo const &);
-    static std::vector<BaseClassInfo> const & base_classes();
-    static std::vector<SubClassInfo> const & sub_classes();
+    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();
 private:
    static py::Class<py::ExtensionInstance>* static_class_object;
-    static std::vector<BaseClassInfo> static_base_class_info;
-    static std::vector<SubClassInfo> static_sub_class_info;
+    static std::vector<py::detail::BaseClassInfo> static_base_class_info;
+    static std::vector<py::detail::DerivedClassInfo> static_derived_class_info;
 };

 #ifdef PY_NO_INLINE_FRIENDS_IN_NAMESPACE // back to global namespace for this GCC bug
@@ -278,8 +284,11 @@ class ReadOnlySetattrFunction : public Function
    String m_name;
 };

+namespace detail
+{
+
 template <class From, class To>
-struct ConversionFunction
+struct DefineConversion
 {
    static void * upcast_ptr(void * v)
    {
@@ -292,6 +301,8 @@ struct ConversionFunction
    }
 };

+}
+
 enum WithoutDowncast { without_downcast };


@@ -395,12 +406,14 @@ class ExtensionClass
    template <class S, class V>
    void declare_base(ExtensionClass<S, V> * base)
    {
-        BaseClassInfo baseInfo(base, &ConversionFunction<S, T>::downcast_ptr);
+        detail::BaseClassInfo baseInfo(base, 
+                            &detail::DefineConversion<S, T>::downcast_ptr);
        ClassRegistry<T>::register_base_class(baseInfo);
        add_base(Ptr(as_object(base), Ptr::new_ref));
        
-        SubClassInfo subInfo(this, &ConversionFunction<T, S>::upcast_ptr);
-        ClassRegistry<S>::register_sub_class(subInfo);
+        detail::DerivedClassInfo derivedInfo(this, 
+                            &detail::DefineConversion<T, S>::upcast_ptr);
+        ClassRegistry<S>::register_derived_class(derivedInfo);
    }
        
    // declare the given class a base class of this and register 
@@ -408,19 +421,20 @@ class ExtensionClass
    template <class S, class V>
    void declare_base(ExtensionClass<S, V> * base, WithoutDowncast)
    {
-        BaseClassInfo baseInfo(base, 0);
+        detail::BaseClassInfo baseInfo(base, 0);
        ClassRegistry<T>::register_base_class(baseInfo);
        add_base(Ptr(as_object(base), Ptr::new_ref));
        
-        SubClassInfo subInfo(this, &ConversionFunction<T, S>::upcast_ptr);
-        ClassRegistry<S>::register_sub_class(subInfo);
+        detail::DerivedClassInfo derivedInfo(this, 
+                           &detail::DefineConversion<T, S>::upcast_ptr);
+        ClassRegistry<S>::register_derived_class(derivedInfo);
    }
    
 private:
    typedef InstanceValueHolder<T,U> Holder;
    
-    virtual std::vector<BaseClassInfo> const & base_classes() const;
-    virtual std::vector<SubClassInfo> const & sub_classes() const;
+    virtual std::vector<detail::BaseClassInfo> const & base_classes() const;
+    virtual std::vector<detail::DerivedClassInfo> const & derived_classes() const;
    virtual void * convert_from_holder(InstanceHolderBase * v) const;

    template <class Signature>
@@ -541,16 +555,18 @@ ExtensionClass<T, U>::ExtensionClass(const char* name)

 template <class T, class U>
 inline
-std::vector<BaseClassInfo> const & ExtensionClass<T, U>::base_classes() const
+std::vector<detail::BaseClassInfo> const & 
+ExtensionClass<T, U>::base_classes() const
 {
    return ClassRegistry<T>::base_classes();
 }

 template <class T, class U>
 inline
-std::vector<SubClassInfo> const & ExtensionClass<T, U>::sub_classes() const
+std::vector<detail::DerivedClassInfo> const & 
+ExtensionClass<T, U>::derived_classes() const
 {
-    return ClassRegistry<T>::sub_classes();
+    return ClassRegistry<T>::derived_classes();
 }
       
 template <class T, class U>
@@ -585,27 +601,27 @@ inline void ClassRegistry<T>::unregister_class(Class<ExtensionInstance>* p)
 }

 template <class T>
-void ClassRegistry<T>::register_base_class(BaseClassInfo const & i)
+void ClassRegistry<T>::register_base_class(py::detail::BaseClassInfo const & i)
 {
    static_base_class_info.push_back(i);
 }

 template <class T>
-void ClassRegistry<T>::register_sub_class(SubClassInfo const & i)
+void ClassRegistry<T>::register_derived_class(py::detail::DerivedClassInfo const & i)
 {
-    static_sub_class_info.push_back(i);
+    static_derived_class_info.push_back(i);
 }

 template <class T>
-std::vector<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<SubClassInfo> const & ClassRegistry<T>::sub_classes()
+std::vector<py::detail::DerivedClassInfo> const & ClassRegistry<T>::derived_classes()
 {
-    return static_sub_class_info;
+    return static_derived_class_info;
 }

 //
@@ -614,9 +630,9 @@ std::vector<SubClassInfo> const & ClassRegistry<T>::sub_classes()
 template <class T>
 Class<py::ExtensionInstance>* ClassRegistry<T>::static_class_object;
 template <class T>
-std::vector<BaseClassInfo> ClassRegistry<T>::static_base_class_info;
+std::vector<py::detail::BaseClassInfo> ClassRegistry<T>::static_base_class_info;
 template <class T>
-std::vector<SubClassInfo> ClassRegistry<T>::static_sub_class_info;
+std::vector<py::detail::DerivedClassInfo> ClassRegistry<T>::static_derived_class_info;

 } // namespace py

--- a/newtypes.h
+++ b/newtypes.h
@@ -61,11 +61,6 @@ class TypeObjectBase : public PythonType
    virtual PyObject* instance_getattr(PyObject* instance, const char* name) const;
    virtual int instance_setattr(PyObject* instance, const char* name, PyObject* value) const;

-    virtual void * try_class_conversions(InstanceHolderBase*) const { return 0; }
-    virtual void * try_superclass_conversions(InstanceHolderBase*) const { return 0; }
-    virtual void * try_subclass_conversions(InstanceHolderBase*) const { return 0; }
-    virtual void * convert_from_holder(InstanceHolderBase*) const { return 0; }
-
    // Dealloc is a special case, since every type needs a nonzero tp_dealloc slot.
    virtual void instance_dealloc(PyObject*) const = 0;

--- a/subclass.h
+++ b/subclass.h
@@ -73,6 +73,11 @@ class Class
    int setattr(const char* name, PyObject* value);
    PyObject* call(PyObject* args, PyObject* keywords);
    
+    virtual void * try_class_conversions(InstanceHolderBase*) const { return 0; }
+    virtual void * try_base_class_conversions(InstanceHolderBase*) const { return 0; }
+    virtual void * try_derived_class_conversions(InstanceHolderBase*) const { return 0; }
+    virtual void * convert_from_holder(InstanceHolderBase*) const { return 0; }
+
 protected:
    void add_base(Ptr base);