2fbbbca1a0
the declaring file for a given type via the new member function osgIntrospection::Type::getDeclaringFile. This information is useful in order to know what header to include when auto-generating wrappers for a given type. During the C# wrapper generator development I've been keeping the declaring file configuration state up-to-date manually with changes to OSG, and it's proven to require substantial effort. So it would be extremely valuable to get this change in before 2.0 to reduce maintenance during the lifetime of the release. It'll also be equally useful to others looking to create wrapper generators using osgIntrospection. This is a fairly simple change and was tested with a fresh rebuild of the entire suite of osgWrapper libraries, so it should be relatively low risk (fingers crossed)."
567 lines
18 KiB
C++
567 lines
18 KiB
C++
/* -*-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.
|
|
*/
|
|
//osgIntrospection - Copyright (C) 2005 Marco Jez
|
|
#ifndef OSGINTROSPECTION_TYPE
|
|
#define OSGINTROSPECTION_TYPE
|
|
|
|
#include <osgIntrospection/Export>
|
|
#include <osgIntrospection/Exceptions>
|
|
#include <osgIntrospection/Value>
|
|
#include <osgIntrospection/CustomAttributeProvider>
|
|
#include <osgIntrospection/ExtendedTypeInfo>
|
|
|
|
#include <string>
|
|
#include <typeinfo>
|
|
#include <vector>
|
|
#include <map>
|
|
#include <algorithm>
|
|
|
|
namespace osgIntrospection
|
|
{
|
|
|
|
// forward declarations
|
|
class MethodInfo;
|
|
class PropertyInfo;
|
|
class ParameterInfo;
|
|
class ReaderWriter;
|
|
class ConstructorInfo;
|
|
struct Comparator;
|
|
|
|
// typedefs for member info lists
|
|
typedef std::vector<const MethodInfo* > MethodInfoList;
|
|
typedef std::vector<const PropertyInfo* > PropertyInfoList;
|
|
typedef std::vector<const ParameterInfo* > ParameterInfoList;
|
|
typedef std::vector<const ConstructorInfo* > ConstructorInfoList;
|
|
|
|
// typedefs for member info map
|
|
typedef std::map<const Type*, PropertyInfoList > PropertyInfoMap;
|
|
typedef std::map<const Type*, MethodInfoList > MethodInfoMap;
|
|
|
|
// typedef for enum label map
|
|
typedef std::map<int, std::string> EnumLabelMap;
|
|
|
|
// typedef for base type
|
|
typedef std::vector<const Type* > TypeList;
|
|
|
|
/// Objects of class Type are used to maintain information about
|
|
/// reflected types. They also provide a number of services, like
|
|
/// instance creation and dynamic calling of methods.
|
|
/// All details about the data type being described are available
|
|
/// at runtime, provided that the type was defined (and not just
|
|
/// declared) through a Reflector class.
|
|
/// It is not possible to modify a Type object once it has been
|
|
/// created, unless you are a class derived from Reflector (which
|
|
/// has firm friendship with this class).
|
|
class OSGINTROSPECTION_EXPORT Type: public CustomAttributeProvider
|
|
{
|
|
public:
|
|
/// Function category specifier for querying constructors and
|
|
/// methods.
|
|
enum FunctionCategory
|
|
{
|
|
PUBLIC_FUNCTIONS,
|
|
PROTECTED_FUNCTIONS
|
|
};
|
|
|
|
/// Destructor. Note that this class is not meant to be subclassed.
|
|
~Type();
|
|
|
|
/// Returns a reference to the std::type_info instance associated
|
|
/// to this Type.
|
|
inline const std::type_info& getStdTypeInfo() const;
|
|
|
|
/// Returns a reference to the ExtendedTypeInfo associated
|
|
/// to this Type.
|
|
inline ExtendedTypeInfo getExtendedTypeInfo() const;
|
|
|
|
/// Returns true if this Type is defined, false if it's just
|
|
/// declared. See class Reflector if you want to create a new Type.
|
|
inline bool isDefined() const;
|
|
|
|
/// Returns the name of the reflected type.
|
|
inline const std::string& getName() const;
|
|
|
|
/// Returns the namespace of the reflected type.
|
|
inline const std::string& getNamespace() const;
|
|
|
|
/// Returns the qualified name of the reflected type. The qualified
|
|
/// name is formed by the namespace, if present, plus other modifiers
|
|
/// like 'const' and/or '*' (pointer) where applicable.
|
|
inline std::string getQualifiedName() const;
|
|
|
|
/// Returns true if either the fully-qualified name or one of the
|
|
/// name aliases match the given argument
|
|
inline bool matchesName(const std::string& name) const;
|
|
|
|
/// Returns the brief help of the reflected type.
|
|
inline virtual const std::string& getBriefHelp() const;
|
|
|
|
/// Returns the detailed help of the reflected type.
|
|
inline virtual const std::string& getDetailedHelp() const;
|
|
|
|
/// Returns the number of base types.
|
|
/// This number is zero if the type is not derived from any other
|
|
/// type.
|
|
inline int getNumBaseTypes() const;
|
|
|
|
/// Returns the i-th base type.
|
|
inline const Type& getBaseType(int i) const;
|
|
|
|
/// Returns the base type list.
|
|
inline const TypeList& getBaseTypeList() const;
|
|
|
|
/// Returns the number of type name aliases.
|
|
inline int getNumAliases() const;
|
|
|
|
/// Returns the i-th name alias
|
|
const std::string& getAlias(int i) const;
|
|
|
|
/// Returns whether the reflected type is abstract.
|
|
inline bool isAbstract() const;
|
|
|
|
/// Returns whether the reflected type is "atomic", that is
|
|
/// it can be rendered to and decoded from a stream directly.
|
|
inline bool isAtomic() const;
|
|
|
|
/// Returns whether the reflected type is an enumeration.
|
|
inline bool isEnum() const;
|
|
|
|
/// Returns whether the reflected type is the type void.
|
|
inline bool isVoid() const;
|
|
|
|
/// Returns true if the reflected type is a pointer, false otherwise.
|
|
inline bool isPointer() const;
|
|
|
|
/// Returns true if the reflected type is a pointer AND it is const,
|
|
/// false otherwise.
|
|
inline bool isConstPointer() const;
|
|
|
|
/// Returns true if the reflected type is a pointer AND it is not
|
|
/// const, false otherwise.
|
|
inline bool isNonConstPointer() const;
|
|
|
|
/// Returns the pointed type. If the reflected type is not a pointer,
|
|
/// the object returned is typeof(void).
|
|
inline const Type& getPointedType() const;
|
|
|
|
/// Returns true if the reflected type is a reference, false otherwise.
|
|
inline bool isReference() const;
|
|
|
|
/// Returns true if the reflected type is a reference AND it is const,
|
|
/// false otherwise.
|
|
inline bool isConstReference() const;
|
|
|
|
/// Returns true if the reflected type is a reference AND it is not
|
|
/// const, false otherwise.
|
|
inline bool isNonConstReference() const;
|
|
|
|
/// Returns the referenced type. If the reflected type is not a reference,
|
|
/// the object returned is typeof(void).
|
|
inline const Type& getReferencedType() const;
|
|
|
|
/// Returns the list of properties defined for this type. The list
|
|
/// does not include properties inherited from base types.
|
|
inline const PropertyInfoList& getProperties() const;
|
|
|
|
/// Fills a list of properties that are either defined in this Type
|
|
/// or in inherited types.
|
|
void getAllProperties(PropertyInfoList& props) const;
|
|
|
|
/// Fills a map of "type <-> propertyInfoList" that are either defined in this Type
|
|
/// or in inherited types.
|
|
void getPropertiesMap(PropertyInfoMap& props) const;
|
|
|
|
/// Returns the list of constructors defined for this type.
|
|
inline const ConstructorInfoList& getConstructors(FunctionCategory category = PUBLIC_FUNCTIONS) const;
|
|
|
|
/// Returns the list of methods defined for this type. The list
|
|
/// does not include methods inherited from base types.
|
|
inline const MethodInfoList& getMethods(FunctionCategory category = PUBLIC_FUNCTIONS) const;
|
|
|
|
/// Fills a list of methods that are either defined in this Type
|
|
/// or in inherited types.
|
|
void getAllMethods(MethodInfoList& methods, FunctionCategory category = PUBLIC_FUNCTIONS) const;
|
|
|
|
/// Fills a map of "type <-> MethodInfoList" that are either defined in this Type
|
|
/// or in inherited types.
|
|
void getMethodsMap(MethodInfoMap& methods, FunctionCategory category = PUBLIC_FUNCTIONS) const;
|
|
|
|
/// Returns the map of enumeration labels. If the type is not an
|
|
/// enumeration, an empty map is returned.
|
|
inline const EnumLabelMap& getEnumLabels() const;
|
|
|
|
/// Searches for a constructor that can be called with the given list
|
|
/// of arguments without raising type conversion errors. If more than
|
|
/// one constructors are suitable for calling, the best match is
|
|
/// returned.
|
|
const ConstructorInfo* getCompatibleConstructor(const ValueList& values) const;
|
|
|
|
/// Searches for a constructor whose parameters match exactly the given
|
|
/// list of parameter descriptions.
|
|
const ConstructorInfo* getConstructor(const ParameterInfoList& params) const;
|
|
|
|
/// Searches for a method that can be called with the given list of
|
|
/// arguments without raising type conversion errors. If more than
|
|
/// one method are suitable for calling, the best match is returned.
|
|
const MethodInfo* getCompatibleMethod(const std::string& name, const ValueList& values, bool inherit) const;
|
|
|
|
/// Searches for a method whose parameters match exactly the given
|
|
/// list of parameter descriptions.
|
|
const MethodInfo* getMethod(const std::string& name, const ParameterInfoList& params, bool inherit) const;
|
|
|
|
/// Searches for a property given its name, type and list of indices.
|
|
/// Only exact matches are returned.
|
|
const PropertyInfo* getProperty(const std::string& name, const Type& ptype, const ParameterInfoList& indices, bool inherit) const;
|
|
|
|
/// Searches for a suitable method and invokes it with the given list
|
|
/// of arguments (const instance).
|
|
Value invokeMethod(const std::string& name, const Value& instance, ValueList& args, bool inherit) const;
|
|
|
|
/// Searches for a suitable method and invokes it with the given list
|
|
/// of arguments.
|
|
Value invokeMethod(const std::string& name, Value& instance, ValueList& args, bool inherit) const;
|
|
|
|
/// Returns whether the reflected type is derived from another type.
|
|
bool isSubclassOf(const Type& type) const;
|
|
|
|
/// Returns the instance of the reader/writer object assigned to
|
|
/// this type, if any. Otherwise it returns the null pointer.
|
|
inline const ReaderWriter* getReaderWriter() const;
|
|
|
|
/// Returns the instance of the comparator object assigned to
|
|
/// this type, if any. Otherwise it returns the null pointer.
|
|
inline const Comparator* getComparator() const;
|
|
|
|
/// Returns the path to the file where this type is declared,
|
|
/// relative the the OpenSceneGraph include directory. Returns
|
|
/// the empty string if no path information is available.
|
|
inline const std::string &getDeclaringFile() const;
|
|
|
|
/// Creates an instance of the reflected type. The returned Value
|
|
/// can be casted to T*, where T is the reflected type. If the type
|
|
/// is abstract, an exception is thrown.
|
|
Value createInstance(ValueList& args) const;
|
|
inline Value createInstance() const;
|
|
|
|
protected:
|
|
Type(const ExtendedTypeInfo &ti)
|
|
: _ti(ti),
|
|
_is_const(false),
|
|
_is_abstract(false),
|
|
_pointed_type(0),
|
|
_referenced_type(0),
|
|
_is_defined(false),
|
|
_rw(0),
|
|
_cmp(0)
|
|
{
|
|
}
|
|
|
|
// throws an exception if the type is not defined.
|
|
void check_defined() const;
|
|
|
|
virtual void getInheritedProviders(CustomAttributeProviderList& providers) const;
|
|
|
|
private:
|
|
template<typename C> friend class Reflector;
|
|
template<typename C> friend struct TypeNameAliasProxy;
|
|
friend class Reflection;
|
|
|
|
Type(const Type& copy): CustomAttributeProvider(copy), _ti(copy._ti) {}
|
|
|
|
ExtendedTypeInfo _ti;
|
|
|
|
std::string _name;
|
|
std::string _namespace;
|
|
|
|
TypeList _base;
|
|
|
|
bool _is_const;
|
|
bool _is_abstract;
|
|
const Type* _pointed_type;
|
|
const Type* _referenced_type;
|
|
|
|
ConstructorInfoList _cons;
|
|
ConstructorInfoList _protected_cons;
|
|
PropertyInfoList _props;
|
|
MethodInfoList _methods;
|
|
MethodInfoList _protected_methods;
|
|
|
|
EnumLabelMap _labels;
|
|
bool _is_defined;
|
|
|
|
const ReaderWriter* _rw;
|
|
const Comparator* _cmp;
|
|
|
|
typedef std::vector<std::string> AliasList;
|
|
AliasList _aliases;
|
|
|
|
std::string _briefHelp;
|
|
std::string _detailedHelp;
|
|
|
|
std::string _declaringFile;
|
|
};
|
|
|
|
// OPERATORS
|
|
|
|
/// Equality test operator. Returns true if the two instances of Type
|
|
/// describe the same type, false otherwise.
|
|
inline bool operator==(const Type& t1, const Type& t2)
|
|
{
|
|
return (t1.getStdTypeInfo() == t2.getStdTypeInfo()) != 0;
|
|
}
|
|
|
|
/// Inequality test operator. Returns false if the two instances of Type
|
|
/// describe the same type, true otherwise.
|
|
inline bool operator!=(const Type& t1, const Type& t2)
|
|
{
|
|
return (t1.getStdTypeInfo() != t2.getStdTypeInfo()) != 0;
|
|
}
|
|
|
|
/// Less than operator. Returns true if the first type comes before the
|
|
/// second one. The actual ordering is implementation-dependent.
|
|
inline bool operator<(const Type& t1, const Type& t2)
|
|
{
|
|
return (t1.getStdTypeInfo().before(t2.getStdTypeInfo())) != 0;
|
|
}
|
|
|
|
/// Greater than or equal to operator. Returns !operator<().
|
|
inline bool operator>=(const Type& t1, const Type& t2)
|
|
{
|
|
return !operator<(t1, t2);
|
|
}
|
|
|
|
// INLINE METHODS
|
|
|
|
inline void Type::check_defined() const
|
|
{
|
|
if (!_is_defined)
|
|
throw TypeNotDefinedException(_ti);
|
|
}
|
|
|
|
inline const std::type_info& Type::getStdTypeInfo() const
|
|
{
|
|
return _ti.getStdTypeInfo();
|
|
}
|
|
|
|
inline ExtendedTypeInfo Type::getExtendedTypeInfo() const
|
|
{
|
|
return _ti;
|
|
}
|
|
|
|
inline const std::string& Type::getName() const
|
|
{
|
|
check_defined();
|
|
return _name;
|
|
}
|
|
|
|
inline const std::string& Type::getNamespace() const
|
|
{
|
|
check_defined();
|
|
return _namespace;
|
|
}
|
|
|
|
inline std::string Type::getQualifiedName() const
|
|
{
|
|
check_defined();
|
|
std::string qname;
|
|
if (_is_const) qname = "const ";
|
|
if (!_namespace.empty())
|
|
{
|
|
qname.append(_namespace);
|
|
qname.append("::");
|
|
}
|
|
qname.append(_name);
|
|
if (_pointed_type)
|
|
qname.append(" *");
|
|
else if (_referenced_type)
|
|
qname.append(" &");
|
|
return qname;
|
|
}
|
|
|
|
inline const std::string& Type::getBriefHelp() const
|
|
{
|
|
return _briefHelp;
|
|
}
|
|
|
|
inline const std::string& Type::getDetailedHelp() const
|
|
{
|
|
return _detailedHelp;
|
|
}
|
|
|
|
inline int Type::getNumBaseTypes() const
|
|
{
|
|
check_defined();
|
|
return static_cast<int>(_base.size());
|
|
}
|
|
|
|
inline bool Type::isConstPointer() const
|
|
{
|
|
check_defined();
|
|
return _is_const && _pointed_type;
|
|
}
|
|
|
|
inline bool Type::isNonConstPointer() const
|
|
{
|
|
check_defined();
|
|
return !_is_const && _pointed_type;
|
|
}
|
|
|
|
inline bool Type::isConstReference() const
|
|
{
|
|
check_defined();
|
|
return _is_const && _referenced_type;
|
|
}
|
|
|
|
inline bool Type::isNonConstReference() const
|
|
{
|
|
check_defined();
|
|
return !_is_const && _referenced_type;
|
|
}
|
|
|
|
inline bool Type::isAbstract() const
|
|
{
|
|
check_defined();
|
|
return _is_abstract;
|
|
}
|
|
|
|
inline bool Type::isAtomic() const
|
|
{
|
|
check_defined();
|
|
return _rw != 0;
|
|
}
|
|
|
|
inline const PropertyInfoList& Type::getProperties() const
|
|
{
|
|
check_defined();
|
|
return _props;
|
|
}
|
|
|
|
inline const ConstructorInfoList& Type::getConstructors(FunctionCategory category) const
|
|
{
|
|
check_defined();
|
|
return category == PUBLIC_FUNCTIONS ? _cons : _protected_cons;
|
|
}
|
|
|
|
inline const MethodInfoList& Type::getMethods(FunctionCategory category) const
|
|
{
|
|
check_defined();
|
|
return category == PUBLIC_FUNCTIONS ? _methods : _protected_methods;
|
|
}
|
|
|
|
inline bool Type::isPointer() const
|
|
{
|
|
check_defined();
|
|
return _pointed_type != 0;
|
|
}
|
|
|
|
inline bool Type::isReference() const
|
|
{
|
|
check_defined();
|
|
return _referenced_type != 0;
|
|
}
|
|
|
|
inline bool Type::isVoid() const
|
|
{
|
|
return (_ti == extended_typeid<void>()) != 0;
|
|
}
|
|
|
|
inline const Type& Type::getPointedType() const
|
|
{
|
|
check_defined();
|
|
if (_pointed_type)
|
|
return *_pointed_type;
|
|
return Reflection::type_void();
|
|
}
|
|
|
|
inline const Type& Type::getReferencedType() const
|
|
{
|
|
check_defined();
|
|
if (_referenced_type)
|
|
return *_referenced_type;
|
|
return Reflection::type_void();
|
|
}
|
|
|
|
inline bool Type::isEnum() const
|
|
{
|
|
check_defined();
|
|
return !_labels.empty();
|
|
}
|
|
|
|
inline const EnumLabelMap& Type::getEnumLabels() const
|
|
{
|
|
check_defined();
|
|
return _labels;
|
|
}
|
|
|
|
inline bool Type::isDefined() const
|
|
{
|
|
return _is_defined;
|
|
}
|
|
|
|
inline const ReaderWriter* Type::getReaderWriter() const
|
|
{
|
|
check_defined();
|
|
return _rw;
|
|
}
|
|
|
|
inline const Comparator* Type::getComparator() const
|
|
{
|
|
check_defined();
|
|
return _cmp;
|
|
}
|
|
|
|
inline const Type& Type::getBaseType(int i) const
|
|
{
|
|
check_defined();
|
|
return *_base.at(i);
|
|
}
|
|
|
|
inline const TypeList& Type::getBaseTypeList() const
|
|
{
|
|
check_defined();
|
|
return _base;
|
|
}
|
|
|
|
inline Value Type::createInstance() const
|
|
{
|
|
ValueList args;
|
|
return createInstance(args);
|
|
}
|
|
|
|
inline int Type::getNumAliases() const
|
|
{
|
|
return static_cast<int>(_aliases.size());
|
|
}
|
|
|
|
inline const std::string& Type::getAlias(int i) const
|
|
{
|
|
return _aliases[i];
|
|
}
|
|
|
|
inline bool Type::matchesName(const std::string& name) const
|
|
{
|
|
if (getQualifiedName() == name)
|
|
return true;
|
|
if (std::find(_aliases.begin(), _aliases.end(), name) != _aliases.end())
|
|
return true;
|
|
return false;
|
|
}
|
|
|
|
inline const std::string &Type::getDeclaringFile() const
|
|
{
|
|
return _declaringFile;
|
|
}
|
|
}
|
|
|
|
#endif
|