Added new compiler tests. 1. To see whether it allows use of non extern C

2005-01-21  Murray Cumming  <murrayc@localhost.localdomain>

        * configure.in, scripts/cxx.m4, glibmm/glibmmconfig.h.in: Added new
        compiler tests.
        1. To see whether it allows use of non extern C functions
        as extern C callbacks, because the Tru64 compiler does not
        allow this, when using strict_ansi. We do not actually use this yet.
        2. To see whether it allows us to define a template that uses an
        undefined type, even if we do not use it before defining the type.
        Tru64 does not allow this. That's probably correct.
        * glib/glibmm/container.h: #ifdef out a dynamic_cast that Tru64
        does not allow, and which I can not think of a better place to put.
        See the comment in the code.
        * glib/glibmm/containerhandler_helpers.h: When the compiler does not
        alllow the GObject and GtkObject (dynamic_cast of) specializations
        here, then put them in glib/glibmm/object.h and
        gtkmm/gtk/src/object.hg instead.- needed by Tru64 compiler.
        * glib/glibmm/value.h, value_custom.[h|cc]: Conditionally moved
        the RefPtr Value specialization into object.h, as above.
        * glib/src/ optiongroup.ccg, spawn.ccg, thread.ccg: Make C callacks
        separate extern C.
        * glib/src/optiongroup.ccg: Do not use the StringArrayHandle,
        because the Tru64 compiler has problems with it - see comments
        in code.
        * glib/src/optionentry.hg: Remove the include of value.h, because
        it is not used and it causes a Tru64 compile error in
        optioncontext.cc because its templates are included before the
        types that the template uses.

2005-01-19  Murray Cumming  <murrayc@murrayc.com>

        * configure.in, scripts/cxx.m4, glibmm/glibmmconfig.h.in: Added a
        compiler test, because the IRIX MipsPro compiler does not allow the
        inline initialization of ustring::npos.
        * glib/glibmm/ustring.[h|cc]: When the compiler does not support the
        inline initialization of npos, initialize it in the .cc file.
        Declare partial specializations of the SequenceString inner class
        inside the class - needed by IRIX MipsPro compiler.

1 files changed, 131 insertions, 0 deletions

diff --git a/glib/glibmm/object.h b/glib/glibmm/object.h
index d9bca6e1..3f196f9c 100644
--- a/glib/glibmm/object.h
+++ b/glib/glibmm/object.h
@@ -25,6 +25,7 @@
 #include <glibmm/quark.h>
 #include <glibmm/refptr.h>
 #include <glibmm/utility.h> /* Could be private, but that would be tedious. */
+#include <glibmm/containerhandle_shared.h> //Because its specializations may be here.
 #include <glibmm/value.h>
 
 #ifndef DOXYGEN_SHOULD_SKIP_THIS
@@ -145,6 +146,136 @@ private:
   //virtual void set_manage();
 };
 
+
+//For some (proably, more spec-compliant) compilers, these specializations must
+//be next to the objects that they use.
+#ifndef GLIBMM_CAN_USE_DYNAMIC_CAST_IN_UNUSED_TEMPLATE_WITHOUT_DEFINITION
+#ifndef DOXYGEN_SHOULD_SKIP_THIS /* hide the specializations */
+
+namespace Container_Helpers
+{
+
+/** Partial specialization for pointers to GObject instances.
+ * @ingroup ContHelpers
+ * The C++ type is always a Glib::RefPtr<>.
+ */
+template <class T>
+struct TypeTraits< Glib::RefPtr<T> >
+{
+  typedef Glib::RefPtr<T>              CppType;
+  typedef typename T::BaseObjectType * CType;
+  typedef typename T::BaseObjectType * CTypeNonConst;
+
+  static CType   to_c_type      (const CppType& ptr) { return Glib::unwrap(ptr);     }
+  static CType   to_c_type      (CType          ptr) { return ptr;                   }
+  static CppType to_cpp_type    (CType          ptr)
+  {
+    //return Glib::wrap(ptr, true);
+
+    //We copy/paste the wrap() implementation here,
+    //because we can not use a specific Glib::wrap(CType) overload here,
+    //because that would be "dependent", and g++ 3.4 does not allow that.
+    //The specific Glib::wrap() overloads don't do anything special anyway.
+    GObject* cobj = (GObject*)const_cast<CTypeNonConst>(ptr);
+    return Glib::RefPtr<T>( dynamic_cast<T*>(Glib::wrap_auto(cobj, true /* take_copy */)) );
+    //We use dynamic_cast<> in case of multiple inheritance.
+  }
+  
+  static void    release_c_type (CType          ptr)
+  {
+    GLIBMM_DEBUG_UNREFERENCE(0, ptr);
+    g_object_unref(ptr);
+  }
+};
+
+//This confuse the SUN Forte compiler, so we ifdef it out:
+#ifdef GLIBMM_HAVE_DISAMBIGUOUS_CONST_TEMPLATE_SPECIALIZATIONS
+
+/** Partial specialization for pointers to const GObject instances.
+ * @ingroup ContHelpers
+ * The C++ type is always a Glib::RefPtr<>.
+ */
+template <class T>
+struct TypeTraits< Glib::RefPtr<const T> >
+{
+  typedef Glib::RefPtr<const T>              CppType;
+  typedef const typename T::BaseObjectType * CType;
+  typedef typename T::BaseObjectType *       CTypeNonConst;
+
+  static CType   to_c_type      (const CppType& ptr) { return Glib::unwrap(ptr);     }
+  static CType   to_c_type      (CType          ptr) { return ptr;                   }
+  static CppType to_cpp_type    (CType          ptr)
+  {
+    //return Glib::wrap(ptr, true);
+
+    //We copy/paste the wrap() implementation here,
+    //because we can not use a specific Glib::wrap(CType) overload here,
+    //because that would be "dependent", and g++ 3.4 does not allow that.
+    //The specific Glib::wrap() overloads don't do anything special anyway.
+    GObject* cobj = (GObject*)(ptr);
+    return Glib::RefPtr<const T>( dynamic_cast<const T*>(Glib::wrap_auto(cobj, true /* take_copy */)) );
+    //We use dynamic_cast<> in case of multiple inheritance.
+  }
+  
+  static void    release_c_type (CType          ptr)
+  {
+    GLIBMM_DEBUG_UNREFERENCE(0, ptr);
+    g_object_unref(const_cast<CTypeNonConst>(ptr));
+  }
+};
+
+#endif //GLIBMM_HAVE_DISAMBIGUOUS_CONST_TEMPLATE_SPECIALIZATIONS
+
+} //namespace Container_Helpers
+
+
+template <class T, class PtrT> inline
+PtrT Value_Pointer<T,PtrT>::get_(Glib::Object*) const
+{
+  return dynamic_cast<T*>(get_object());
+}
+
+
+/** Partial specialization for RefPtr<> to Glib::Object.
+ * @ingroup glibmmValue
+ */
+template <class T>
+class Value< Glib::RefPtr<T> > : public ValueBase_Object
+{
+public:
+  typedef Glib::RefPtr<T>             CppType;
+  typedef typename T::BaseObjectType* CType;
+
+  static GType value_type() { return T::get_base_type(); }
+
+  void set(const CppType& data) { set_object(data.operator->()); }
+  CppType get() const           { return Glib::RefPtr<T>::cast_dynamic(get_object_copy()); }
+};
+
+//The SUN Forte Compiler has a problem with this: 
+#ifdef GLIBMM_HAVE_DISAMBIGUOUS_CONST_TEMPLATE_SPECIALIZATIONS
+
+/** Partial specialization for RefPtr<> to const Glib::Object.
+ * @ingroup glibmmValue
+ */
+template <class T>
+class Value< Glib::RefPtr<const T> > : public ValueBase_Object
+{
+public:
+  typedef Glib::RefPtr<const T>       CppType;
+  typedef typename T::BaseObjectType* CType;
+
+  static GType value_type() { return T::get_base_type(); }
+
+  void set(const CppType& data) { set_object(const_cast<T*>(data.operator->())); }
+  CppType get() const           { return Glib::RefPtr<T>::cast_dynamic(get_object_copy()); }
+};
+#endif //GLIBMM_HAVE_DISAMBIGUOUS_CONST_TEMPLATE_SPECIALIZATIONS
+
+
+#endif //DOXYGEN_SHOULD_SKIP_THIS
+#endif //GLIBMM_CAN_USE_DYNAMIC_CAST_IN_UNUSED_TEMPLATE_WITHOUT_DEFINITION
+
 } // namespace Glib
 
 #endif /* _GLIBMM_OBJECT_H */