From Mike Wittman, support for reference parameters

include/osgIntrospection/ExtendedTypeInfo

@@ -0,0 +1,123 @@
+/* -*-c++-*- OpenSceneGraph - Copyright (C) 1998-2006 Robert Osfield 
+ *
+ * This library is open source and may be redistributed and/or modified under  
+ * the terms of the OpenSceneGraph Public License (OSGPL) version 0.0 or 
+ * (at your option) any later version.  The full license is in LICENSE file
+ * included with this distribution, and on the openscenegraph.org website.
+ * 
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the 
+ * OpenSceneGraph Public License for more details.
+*/
+
+#ifndef OSGINTROSPECTION_EXTENDEDTYPEINFO_
+#define OSGINTROSPECTION_EXTENDEDTYPEINFO_
+
+#include <typeinfo>
+#include <string>
+#include <osgIntrospection/type_traits>
+
+namespace osgIntrospection
+{
+    /// This class is a wrapper for std::type_info that also records whether
+    /// a type is a reference or const reference.  It permits osgIntrospection
+    /// to make use of reference information that is ignored by typeid(), and
+    /// to generate reference types based on it.  The ExtendedTypeInfo for a
+    /// class can be produced via the extended_typeid() functions, analogous
+    /// to typeid().
+    ///
+    class ExtendedTypeInfo
+    {
+    public:
+        ExtendedTypeInfo(const std::type_info &ti, bool isReference, bool isConstReference) :
+            _ti(&ti), _is_reference(isReference), _is_const_reference(isConstReference)
+        {
+        }
+
+        /// Orders ExtendedTypeInfo based first on std::type_info, then on
+        /// reference, then on const reference.  Note that we can't rely on
+        /// default pointer comparison for std::type_info because it is not
+        /// guaranteed that &typeid(T) always returns the same pointer for a
+        /// given T (thanks Andrew Koenig).
+        bool operator<(const ExtendedTypeInfo &other) const
+        {
+            if (_ti->before(*other._ti))
+                return true;
+            else if (other._ti->before(*_ti))
+                return false;
+            else if (_is_reference < other._is_reference)
+                return true;
+            else if (other._is_reference < _is_reference)
+                return false;
+            else
+                return _is_const_reference < other._is_const_reference;
+        }
+
+        /// Returns true if *this and other are the same type.
+        bool operator==(const ExtendedTypeInfo &other) const
+        {
+            return (*_ti == *other._ti &&
+                    _is_reference == other._is_reference &&
+                    _is_const_reference == other._is_const_reference);
+        }
+
+        /// Gets the std::type_info object for this type.
+        const std::type_info &getStdTypeInfo() const
+        {
+            return *_ti;
+        }
+
+        /// Returns true if this type is a reference or const reference.
+        bool isReference() const
+        {
+            return _is_reference;
+        }
+
+        /// Returns true if this type is a const reference.
+        bool isConstReference() const
+        {
+            return _is_const_reference;
+        }
+
+        /// Returns the name of this type, based on the std::type_info name.
+        std::string name() const
+        {
+            if (_is_const_reference)
+                return std::string("const ") + _ti->name() + " &";
+            else if (_is_reference)
+                return std::string(_ti->name()) + " &";
+            else
+                return _ti->name();
+        }
+
+    private:
+        const std::type_info *_ti;
+        bool _is_reference;
+        bool _is_const_reference;
+    };
+}
+
+/// extended_typeid works like typeid, but returns an ExtendedTypeInfo.  This
+/// version operates on expressions.
+template <typename T>
+osgIntrospection::ExtendedTypeInfo
+extended_typeid(T)
+{
+  return osgIntrospection::ExtendedTypeInfo(typeid(T),
+                                            is_reference<T>::value,
+                                            is_const_reference<T>::value);
+}
+
+/// extended_typeid works like typeid, but returns an ExtendedTypeInfo.  This
+/// version operates on types, which must be specified as a template parameter.
+template <typename T>
+osgIntrospection::ExtendedTypeInfo
+extended_typeid()
+{
+  return osgIntrospection::ExtendedTypeInfo(typeid(T),
+                                            is_reference<T>::value,
+                                            is_const_reference<T>::value);
+}
+
+#endif

include/osgIntrospection/type_traits

@@ -0,0 +1,63 @@
+/* -*-c++-*- OpenSceneGraph - Copyright (C) 1998-2006 Robert Osfield 
+ *
+ * This library is open source and may be redistributed and/or modified under  
+ * the terms of the OpenSceneGraph Public License (OSGPL) version 0.0 or 
+ * (at your option) any later version.  The full license is in LICENSE file
+ * included with this distribution, and on the openscenegraph.org website.
+ * 
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the 
+ * OpenSceneGraph Public License for more details.
+*/
+
+#ifndef OSGINTROSPECTION_TYPE_TRAITS_
+#define OSGINTROSPECTION_TYPE_TRAITS_
+
+
+/// is_reference is a compile-time template predicate to determine if a
+/// type is a reference type.
+template <typename T>
+struct is_reference
+{
+  static const bool value = false;
+};
+
+template <typename T>
+struct is_reference<T &>
+{
+  static const bool value = true;
+};
+
+
+/// is_const_reference is a compile-time template predicate to determine
+/// if a type is a const reference type.
+template <typename T>
+struct is_const_reference
+{
+  static const bool value = false;
+};
+
+template <typename T>
+struct is_const_reference<const T &>
+{
+  static const bool value = true;
+};
+
+
+/// remove_pointer is a compile-time template type mapper that produces
+/// the input type, but with any pointer modifier removed.
+template <typename T>
+struct remove_pointer
+{
+    typedef T type;
+};
+
+template <typename T>
+struct remove_pointer<T *>
+{
+    typedef T type;
+};
+
+
+#endif

src/osgIntrospection/Reflector.cpp

@@ -0,0 +1,11 @@
+#include <osgIntrospection/Reflector>
+
+namespace osgIntrospection
+{
+    template<>
+    void Reflector<void>::init_reference_types()
+    {
+        // Avoid trying to register void & / const void &, which are
+        // illegal types.
+    }
+}