FGFS-4.1/OpenSceneGraph
4
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

From Mike Wittman, added protected function support

Browse Source
This commit is contained in:
Robert Osfield 2007-03-01 11:54:30 +00:00
parent e622959393
commit 6c56383ba9
9 changed files with 3065 additions and 13 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

91
genwrapper.conf
View File

@ -38,7 +38,7 @@ end
#############################################################################
# suppress reflector "osg::CullStack"
suppress reflector "osg::CullStack"
ignore file "osgViewer/GraphicsWindowX11"
ignore file "osgViewer/GraphicsWindowWin32"
@ -295,6 +295,16 @@ end
#############################################################################
# Suppress nested nested class method
configure reflector "osgShadow::OccluderGeometry"
configure method /.*_Edge_.*/
replace with ""
end
end
#############################################################################
# Doxygen doesn't parse ReadFunc and WriteFunc correctly...
configure reflector "osgDB::DotOsgWrapper::ReadFunc"
@ -315,3 +325,82 @@ suppress reflector "osg::ref_ptr< const osg::StateAttribute >"
suppress reflector "osg::ref_ptr< const osgFX::Effect >"
#############################################################################
# Doxygen incorrectly parses function typedefs as methods
configure reflector "osg::BufferObject::Extensions"
configure method "__typedef__void__APIENTRY_P1"
replace with ""
end
configure method "__typedef__GLboolean__APIENTRY_P1"
replace with ""
end
end
configure reflector "osg::Drawable::Extensions"
configure method "__typedef__void__APIENTRY_P1"
replace with ""
end
configure method "__typedef__GLboolean__APIENTRY_P1"
replace with ""
end
end
configure reflector "osg::State"
configure method "__typedef__void__APIENTRY_P1"
replace with ""
end
end
#############################################################################
# avoid functions that use protected types, since those are not handled
# currently
configure reflector "osg::Shader"
configure method /.*_PerContextShader_.*/
replace with ""
end
end
configure reflector "osg::State"
configure method /.*_(ModeStack|AttributeStack|ModeMap|AttributeMap|UniformMap)_.*/
replace with ""
end
end
configure reflector "osgUtil::Optimizer::TextureAtlasBuilder"
configure method /.*_Source_.*/
replace with ""
end
end
configure reflector "osgUtil::Tessellator"
configure method /.*_VertexPtrToIndexMap_.*/
replace with ""
end
end
configure reflector "osgDB::Registry"
configure method /.*_(DynamicLibraryList_iterator|DotOsgWrapperMap)_.*/
replace with ""
end
end
configure reflector "osgText::FadeText"
configure method /.*_ViewBlendColou?rMap_.*/
replace with ""
end
end
configure reflector "osgParticle::PrecipitationEffect"
configure method /.*_PrecipitationDrawableSet_.*/
replace with ""
end
end
configure reflector "osgManipulator::MotionCommand"
configure method /.*_SelectionList_.*/
replace with ""
end
end

16
include/osgIntrospection/Exceptions
View File

@ -60,6 +60,14 @@ namespace osgIntrospection
}
};
struct ProtectedConstructorInvocationException: public ReflectionException
{
ProtectedConstructorInvocationException()
: ReflectionException("cannot invoke protected constructor")
{
}
};
struct InvokeNotImplementedException: public ReflectionException
{
InvokeNotImplementedException()
@ -84,6 +92,14 @@ namespace osgIntrospection
}
};
struct ProtectedMethodInvocationException: public ReflectionException
{
ProtectedMethodInvocationException()
: ReflectionException("cannot invoke protected method")
{
}
};
struct EmptyValueException: public ReflectionException
{
EmptyValueException()

105
include/osgIntrospection/InstanceCreator
View File

@ -343,6 +343,111 @@ namespace osgIntrospection
};
template<typename T>
struct ProtectedConstructorInstanceCreator
{
template<typename P0, typename P1, typename P2, typename P3, typename P4, typename P5, typename P6, typename P7, typename P8, typename P9, typename P10, typename P11, typename P12, typename P13, typename P14, typename P15>
static Value create(Value& , Value& , Value& , Value& , Value& , Value& , Value& , Value& , Value& , Value& , Value& , Value& , Value& , Value& , Value& , Value& )
{
throw ProtectedConstructorInvocationException();
}
template<typename P0, typename P1, typename P2, typename P3, typename P4, typename P5, typename P6, typename P7, typename P8, typename P9, typename P10, typename P11, typename P12, typename P13, typename P14>
static Value create(Value& , Value& , Value& , Value& , Value& , Value& , Value& , Value& , Value& , Value& , Value& , Value& , Value& , Value& , Value& )
{
throw ProtectedConstructorInvocationException();
}
template<typename P0, typename P1, typename P2, typename P3, typename P4, typename P5, typename P6, typename P7, typename P8, typename P9, typename P10, typename P11, typename P12, typename P13>
static Value create(Value& , Value& , Value& , Value& , Value& , Value& , Value& , Value& , Value& , Value& , Value& , Value& , Value& , Value& )
{
throw ProtectedConstructorInvocationException();
}
template<typename P0, typename P1, typename P2, typename P3, typename P4, typename P5, typename P6, typename P7, typename P8, typename P9, typename P10, typename P11, typename P12>
static Value create(Value& , Value& , Value& , Value& , Value& , Value& , Value& , Value& , Value& , Value& , Value& , Value& , Value& )
{
throw ProtectedConstructorInvocationException();
}
template<typename P0, typename P1, typename P2, typename P3, typename P4, typename P5, typename P6, typename P7, typename P8, typename P9, typename P10, typename P11>
static Value create(Value& , Value& , Value& , Value& , Value& , Value& , Value& , Value& , Value& , Value& , Value& , Value& )
{
throw ProtectedConstructorInvocationException();
}
template<typename P0, typename P1, typename P2, typename P3, typename P4, typename P5, typename P6, typename P7, typename P8, typename P9, typename P10>
static Value create(Value& , Value& , Value& , Value& , Value& , Value& , Value& , Value& , Value& , Value& , Value& )
{
throw ProtectedConstructorInvocationException();
}
template<typename P0, typename P1, typename P2, typename P3, typename P4, typename P5, typename P6, typename P7, typename P8, typename P9>
static Value create(Value& , Value& , Value& , Value& , Value& , Value& , Value& , Value& , Value& , Value& )
{
throw ProtectedConstructorInvocationException();
}
template<typename P0, typename P1, typename P2, typename P3, typename P4, typename P5, typename P6, typename P7, typename P8>
static Value create(Value& , Value& , Value& , Value& , Value& , Value& , Value& , Value& , Value& )
{
throw ProtectedConstructorInvocationException();
}
template<typename P0, typename P1, typename P2, typename P3, typename P4, typename P5, typename P6, typename P7>
static Value create(Value& , Value& , Value& , Value& , Value& , Value& , Value& , Value& )
{
throw ProtectedConstructorInvocationException();
}
template<typename P0, typename P1, typename P2, typename P3, typename P4, typename P5, typename P6>
static Value create(Value& , Value& , Value& , Value& , Value& , Value& , Value& )
{
throw ProtectedConstructorInvocationException();
}
template<typename P0, typename P1, typename P2, typename P3, typename P4, typename P5>
static Value create(Value& , Value& , Value& , Value& , Value& , Value& )
{
throw ProtectedConstructorInvocationException();
}
template<typename P0, typename P1, typename P2, typename P3, typename P4>
static Value create(Value& , Value& , Value& , Value& , Value& )
{
throw ProtectedConstructorInvocationException();
}
template<typename P0, typename P1, typename P2, typename P3>
static Value create(Value& , Value& , Value& , Value& )
{
throw ProtectedConstructorInvocationException();
}
template<typename P0, typename P1, typename P2>
static Value create(Value& , Value& , Value& )
{
throw ProtectedConstructorInvocationException();
}
template<typename P0, typename P1>
static Value create(Value& , Value& )
{
throw ProtectedConstructorInvocationException();
}
template<typename P0>
static Value create(Value& )
{
throw ProtectedConstructorInvocationException();
}
static Value create()
{
throw ProtectedConstructorInvocationException();
}
};
}

1227
include/osgIntrospection/ReflectionMacros
View File

File diff suppressed because it is too large Load Diff

32
include/osgIntrospection/Reflector
View File

@ -89,6 +89,9 @@ namespace osgIntrospection
/// Adds a method description to the current type.
MethodInfo* addMethod(MethodInfo* mi);
/// Adds a protected method description to the current type.
MethodInfo* addProtectedMethod(MethodInfo* mi);
/// Adds an enumeration label to the current type.
void addEnumLabel(int v, const std::string& label, bool strip_namespace = true);
@ -98,6 +101,10 @@ namespace osgIntrospection
/// removed.
ConstructorInfo* addConstructor(ConstructorInfo* ci);
/// Adds a protected constructor description to the current
/// type.
ConstructorInfo* addProtectedConstructor(ConstructorInfo* ci);
/// Returns a string containing the qualified version of 'name'.
std::string qualifyName(const std::string& name) const;
@ -135,6 +142,7 @@ namespace osgIntrospection
typedef std::vector<MethodInfo* > TempMethodList;
TempMethodList _temp_methods;
TempMethodList _temp_protected_methods;
Type* _type;
};
@ -148,6 +156,7 @@ namespace osgIntrospection
{
typedef ValueReflector<T> inherited;
typedef ValueInstanceCreator<typename Reflector<T>::reflected_type> instance_creator_type;
typedef ProtectedConstructorInstanceCreator<typename Reflector<T>::reflected_type> invalid_instance_creator_type;
ValueReflector(const std::string& name, const std::string& ns)
: Reflector<T>(name, ns, false)
@ -168,6 +177,7 @@ namespace osgIntrospection
{
typedef AbstractObjectReflector<T> inherited;
typedef DummyInstanceCreator<typename Reflector<T>::reflected_type> instance_creator_type;
typedef ProtectedConstructorInstanceCreator<typename Reflector<T>::reflected_type> invalid_instance_creator_type;
AbstractObjectReflector(const std::string& name, const std::string& ns)
: Reflector<T>(name, ns, true)
@ -190,6 +200,7 @@ namespace osgIntrospection
{
typedef ObjectReflector<T> inherited;
typedef ObjectInstanceCreator<typename Reflector<T>::reflected_type> instance_creator_type;
typedef ProtectedConstructorInstanceCreator<typename Reflector<T>::reflected_type> invalid_instance_creator_type;
ObjectReflector(const std::string& name, const std::string& ns)
: Reflector<T>(name, ns, false)
@ -872,6 +883,20 @@ namespace osgIntrospection
return mi;
}
template<typename T>
MethodInfo* Reflector<T>::addProtectedMethod(MethodInfo* mi)
{
for (TempMethodList::iterator i=_temp_protected_methods.begin(); i!=_temp_protected_methods.end(); ++i)
{
if (mi->overrides(*i))
return *i;
}
_temp_protected_methods.push_back(mi);
_type->_protected_methods.push_back(mi);
return mi;
}
template<typename T>
void Reflector<T>::addEnumLabel(int v, const std::string& label, bool strip_namespace)
{
@ -894,6 +919,13 @@ namespace osgIntrospection
return ci;
}
template<typename T>
ConstructorInfo* Reflector<T>::addProtectedConstructor(ConstructorInfo* ci)
{
_type->_protected_cons.push_back(ci);
return ci;
}
template<typename T>
std::string Reflector<T>::qualifyName(const std::string& name) const
{

645
include/osgIntrospection/StaticMethodInfo
View File

@ -1218,6 +1218,651 @@ namespace osgIntrospection
FunctionType f_;
};
template<typename C, typename R>
class StaticProtectedMethodInfo0: public MethodInfo
{
public:
StaticProtectedMethodInfo0(const std::string& qname, const ParameterInfoList& plist, std::string briefHelp = std::string(), std::string detailedHelp = std::string())
: MethodInfo(qname, typeof(C), typeof(R), plist, briefHelp, detailedHelp)
{
}
bool isConst() const { return false; }
bool isStatic() const { return true; }
Value invoke(ValueList& /*args*/) const
{
throw ProtectedMethodInvocationException();
}
};
template<typename C, typename R, typename P0>
class StaticProtectedMethodInfo1: public MethodInfo
{
public:
StaticProtectedMethodInfo1(const std::string& qname, const ParameterInfoList& plist, std::string briefHelp = std::string(), std::string detailedHelp = std::string())
: MethodInfo(qname, typeof(C), typeof(R), plist, briefHelp, detailedHelp)
{
}
bool isConst() const { return false; }
bool isStatic() const { return true; }
Value invoke(ValueList& args) const
{
throw ProtectedMethodInvocationException();
}
};
template<typename C, typename R, typename P0, typename P1>
class StaticProtectedMethodInfo2: public MethodInfo
{
public:
StaticProtectedMethodInfo2(const std::string& qname, const ParameterInfoList& plist, std::string briefHelp = std::string(), std::string detailedHelp = std::string())
: MethodInfo(qname, typeof(C), typeof(R), plist, briefHelp, detailedHelp)
{
}
bool isConst() const { return false; }
bool isStatic() const { return true; }
Value invoke(ValueList& args) const
{
throw ProtectedMethodInvocationException();
}
};
template<typename C, typename R, typename P0, typename P1, typename P2>
class StaticProtectedMethodInfo3: public MethodInfo
{
public:
StaticProtectedMethodInfo3(const std::string& qname, const ParameterInfoList& plist, std::string briefHelp = std::string(), std::string detailedHelp = std::string())
: MethodInfo(qname, typeof(C), typeof(R), plist, briefHelp, detailedHelp)
{
}
bool isConst() const { return false; }
bool isStatic() const { return true; }
Value invoke(ValueList& args) const
{
throw ProtectedMethodInvocationException();
}
};
template<typename C, typename R, typename P0, typename P1, typename P2, typename P3>
class StaticProtectedMethodInfo4: public MethodInfo
{
public:
StaticProtectedMethodInfo4(const std::string& qname, const ParameterInfoList& plist, std::string briefHelp = std::string(), std::string detailedHelp = std::string())
: MethodInfo(qname, typeof(C), typeof(R), plist, briefHelp, detailedHelp)
{
}
bool isConst() const { return false; }
bool isStatic() const { return true; }
Value invoke(ValueList& args) const
{
throw ProtectedMethodInvocationException();
}
};
template<typename C, typename R, typename P0, typename P1, typename P2, typename P3, typename P4>
class StaticProtectedMethodInfo5: public MethodInfo
{
public:
StaticProtectedMethodInfo5(const std::string& qname, const ParameterInfoList& plist, std::string briefHelp = std::string(), std::string detailedHelp = std::string())
: MethodInfo(qname, typeof(C), typeof(R), plist, briefHelp, detailedHelp)
{
}
bool isConst() const { return false; }
bool isStatic() const { return true; }
Value invoke(ValueList& args) const
{
throw ProtectedMethodInvocationException();
}
};
template<typename C, typename R, typename P0, typename P1, typename P2, typename P3, typename P4, typename P5>
class StaticProtectedMethodInfo6: public MethodInfo
{
public:
StaticProtectedMethodInfo6(const std::string& qname, const ParameterInfoList& plist, std::string briefHelp = std::string(), std::string detailedHelp = std::string())
: MethodInfo(qname, typeof(C), typeof(R), plist, briefHelp, detailedHelp)
{
}
bool isConst() const { return false; }
bool isStatic() const { return true; }
Value invoke(ValueList& args) const
{
throw ProtectedMethodInvocationException();
}
};
template<typename C, typename R, typename P0, typename P1, typename P2, typename P3, typename P4, typename P5, typename P6>
class StaticProtectedMethodInfo7: public MethodInfo
{
public:
StaticProtectedMethodInfo7(const std::string& qname, const ParameterInfoList& plist, std::string briefHelp = std::string(), std::string detailedHelp = std::string())
: MethodInfo(qname, typeof(C), typeof(R), plist, briefHelp, detailedHelp)
{
}
bool isConst() const { return false; }
bool isStatic() const { return true; }
Value invoke(ValueList& args) const
{
throw ProtectedMethodInvocationException();
}
};
template<typename C, typename R, typename P0, typename P1, typename P2, typename P3, typename P4, typename P5, typename P6, typename P7>
class StaticProtectedMethodInfo8: public MethodInfo
{
public:
StaticProtectedMethodInfo8(const std::string& qname, const ParameterInfoList& plist, std::string briefHelp = std::string(), std::string detailedHelp = std::string())
: MethodInfo(qname, typeof(C), typeof(R), plist, briefHelp, detailedHelp)
{
}
bool isConst() const { return false; }
bool isStatic() const { return true; }
Value invoke(ValueList& args) const
{
throw ProtectedMethodInvocationException();
}
};
template<typename C, typename R, typename P0, typename P1, typename P2, typename P3, typename P4, typename P5, typename P6, typename P7, typename P8>
class StaticProtectedMethodInfo9: public MethodInfo
{
public:
StaticProtectedMethodInfo9(const std::string& qname, const ParameterInfoList& plist, std::string briefHelp = std::string(), std::string detailedHelp = std::string())
: MethodInfo(qname, typeof(C), typeof(R), plist, briefHelp, detailedHelp)
{
}
bool isConst() const { return false; }
bool isStatic() const { return true; }
Value invoke(ValueList& args) const
{
throw ProtectedMethodInvocationException();
}
};
template<typename C, typename R, typename P0, typename P1, typename P2, typename P3, typename P4, typename P5, typename P6, typename P7, typename P8, typename P9>
class StaticProtectedMethodInfo10: public MethodInfo
{
public:
StaticProtectedMethodInfo10(const std::string& qname, const ParameterInfoList& plist, std::string briefHelp = std::string(), std::string detailedHelp = std::string())
: MethodInfo(qname, typeof(C), typeof(R), plist, briefHelp, detailedHelp)
{
}
bool isConst() const { return false; }
bool isStatic() const { return true; }
Value invoke(ValueList& args) const
{
throw ProtectedMethodInvocationException();
}
};
template<typename C, typename R, typename P0, typename P1, typename P2, typename P3, typename P4, typename P5, typename P6, typename P7, typename P8, typename P9, typename P10>
class StaticProtectedMethodInfo11: public MethodInfo
{
public:
StaticProtectedMethodInfo11(const std::string& qname, const ParameterInfoList& plist, std::string briefHelp = std::string(), std::string detailedHelp = std::string())
: MethodInfo(qname, typeof(C), typeof(R), plist, briefHelp, detailedHelp)
{
}
bool isConst() const { return false; }
bool isStatic() const { return true; }
Value invoke(ValueList& args) const
{
throw ProtectedMethodInvocationException();
}
};
template<typename C, typename R, typename P0, typename P1, typename P2, typename P3, typename P4, typename P5, typename P6, typename P7, typename P8, typename P9, typename P10, typename P11>
class StaticProtectedMethodInfo12: public MethodInfo
{
public:
StaticProtectedMethodInfo12(const std::string& qname, const ParameterInfoList& plist, std::string briefHelp = std::string(), std::string detailedHelp = std::string())
: MethodInfo(qname, typeof(C), typeof(R), plist, briefHelp, detailedHelp)
{
}
bool isConst() const { return false; }
bool isStatic() const { return true; }
Value invoke(ValueList& args) const
{
throw ProtectedMethodInvocationException();
}
};
template<typename C, typename R, typename P0, typename P1, typename P2, typename P3, typename P4, typename P5, typename P6, typename P7, typename P8, typename P9, typename P10, typename P11, typename P12>
class StaticProtectedMethodInfo13: public MethodInfo
{
public:
StaticProtectedMethodInfo13(const std::string& qname, const ParameterInfoList& plist, std::string briefHelp = std::string(), std::string detailedHelp = std::string())
: MethodInfo(qname, typeof(C), typeof(R), plist, briefHelp, detailedHelp)
{
}
bool isConst() const { return false; }
bool isStatic() const { return true; }
Value invoke(ValueList& args) const
{
throw ProtectedMethodInvocationException();
}
};
template<typename C, typename R, typename P0, typename P1, typename P2, typename P3, typename P4, typename P5, typename P6, typename P7, typename P8, typename P9, typename P10, typename P11, typename P12, typename P13>
class StaticProtectedMethodInfo14: public MethodInfo
{
public:
StaticProtectedMethodInfo14(const std::string& qname, const ParameterInfoList& plist, std::string briefHelp = std::string(), std::string detailedHelp = std::string())
: MethodInfo(qname, typeof(C), typeof(R), plist, briefHelp, detailedHelp)
{
}
bool isConst() const { return false; }
bool isStatic() const { return true; }
Value invoke(ValueList& args) const
{
throw ProtectedMethodInvocationException();
}
};
template<typename C, typename R, typename P0, typename P1, typename P2, typename P3, typename P4, typename P5, typename P6, typename P7, typename P8, typename P9, typename P10, typename P11, typename P12, typename P13, typename P14>
class StaticProtectedMethodInfo15: public MethodInfo
{
public:
StaticProtectedMethodInfo15(const std::string& qname, const ParameterInfoList& plist, std::string briefHelp = std::string(), std::string detailedHelp = std::string())
: MethodInfo(qname, typeof(C), typeof(R), plist, briefHelp, detailedHelp)
{
}
bool isConst() const { return false; }
bool isStatic() const { return true; }
Value invoke(ValueList& args) const
{
throw ProtectedMethodInvocationException();
}
};
template<typename C, typename R, typename P0, typename P1, typename P2, typename P3, typename P4, typename P5, typename P6, typename P7, typename P8, typename P9, typename P10, typename P11, typename P12, typename P13, typename P14, typename P15>
class StaticProtectedMethodInfo16: public MethodInfo
{
public:
StaticProtectedMethodInfo16(const std::string& qname, const ParameterInfoList& plist, std::string briefHelp = std::string(), std::string detailedHelp = std::string())
: MethodInfo(qname, typeof(C), typeof(R), plist, briefHelp, detailedHelp)
{
}
bool isConst() const { return false; }
bool isStatic() const { return true; }
Value invoke(ValueList& args) const
{
throw ProtectedMethodInvocationException();
}
};
template<typename C>
class StaticProtectedMethodInfo0<C, void>: public MethodInfo
{
public:
StaticProtectedMethodInfo0(const std::string& qname, const ParameterInfoList& plist, std::string briefHelp = std::string(), std::string detailedHelp = std::string())
: MethodInfo(qname, typeof(C), typeof(void), plist, briefHelp, detailedHelp)
{
}
bool isConst() const { return false; }
bool isStatic() const { return true; }
Value invoke(ValueList& /*args*/) const
{
throw ProtectedMethodInvocationException();
}
};
template<typename C, typename P0>
class StaticProtectedMethodInfo1<C, void, P0>: public MethodInfo
{
public:
StaticProtectedMethodInfo1(const std::string& qname, const ParameterInfoList& plist, std::string briefHelp = std::string(), std::string detailedHelp = std::string())
: MethodInfo(qname, typeof(C), typeof(void), plist, briefHelp, detailedHelp)
{
}
bool isConst() const { return false; }
bool isStatic() const { return true; }
Value invoke(ValueList& args) const
{
throw ProtectedMethodInvocationException();
}
};
template<typename C, typename P0, typename P1>
class StaticProtectedMethodInfo2<C, void, P0, P1>: public MethodInfo
{
public:
StaticProtectedMethodInfo2(const std::string& qname, const ParameterInfoList& plist, std::string briefHelp = std::string(), std::string detailedHelp = std::string())
: MethodInfo(qname, typeof(C), typeof(void), plist, briefHelp, detailedHelp)
{
}
bool isConst() const { return false; }
bool isStatic() const { return true; }
Value invoke(ValueList& args) const
{
throw ProtectedMethodInvocationException();
}
};
template<typename C, typename P0, typename P1, typename P2>
class StaticProtectedMethodInfo3<C, void, P0, P1, P2>: public MethodInfo
{
public:
StaticProtectedMethodInfo3(const std::string& qname, const ParameterInfoList& plist, std::string briefHelp = std::string(), std::string detailedHelp = std::string())
: MethodInfo(qname, typeof(C), typeof(void), plist, briefHelp, detailedHelp)
{
}
bool isConst() const { return false; }
bool isStatic() const { return true; }
Value invoke(ValueList& args) const
{
throw ProtectedMethodInvocationException();
}
};
template<typename C, typename P0, typename P1, typename P2, typename P3>
class StaticProtectedMethodInfo4<C, void, P0, P1, P2, P3>: public MethodInfo
{
public:
StaticProtectedMethodInfo4(const std::string& qname, const ParameterInfoList& plist, std::string briefHelp = std::string(), std::string detailedHelp = std::string())
: MethodInfo(qname, typeof(C), typeof(void), plist, briefHelp, detailedHelp)
{
}
bool isConst() const { return false; }
bool isStatic() const { return true; }
Value invoke(ValueList& args) const
{
throw ProtectedMethodInvocationException();
}
};
template<typename C, typename P0, typename P1, typename P2, typename P3, typename P4>
class StaticProtectedMethodInfo5<C, void, P0, P1, P2, P3, P4>: public MethodInfo
{
public:
StaticProtectedMethodInfo5(const std::string& qname, const ParameterInfoList& plist, std::string briefHelp = std::string(), std::string detailedHelp = std::string())
: MethodInfo(qname, typeof(C), typeof(void), plist, briefHelp, detailedHelp)
{
}
bool isConst() const { return false; }
bool isStatic() const { return true; }
Value invoke(ValueList& args) const
{
throw ProtectedMethodInvocationException();
}
};
template<typename C, typename P0, typename P1, typename P2, typename P3, typename P4, typename P5>
class StaticProtectedMethodInfo6<C, void, P0, P1, P2, P3, P4, P5>: public MethodInfo
{
public:
StaticProtectedMethodInfo6(const std::string& qname, const ParameterInfoList& plist, std::string briefHelp = std::string(), std::string detailedHelp = std::string())
: MethodInfo(qname, typeof(C), typeof(void), plist, briefHelp, detailedHelp)
{
}
bool isConst() const { return false; }
bool isStatic() const { return true; }
Value invoke(ValueList& args) const
{
throw ProtectedMethodInvocationException();
}
};
template<typename C, typename P0, typename P1, typename P2, typename P3, typename P4, typename P5, typename P6>
class StaticProtectedMethodInfo7<C, void, P0, P1, P2, P3, P4, P5, P6>: public MethodInfo
{
public:
StaticProtectedMethodInfo7(const std::string& qname, const ParameterInfoList& plist, std::string briefHelp = std::string(), std::string detailedHelp = std::string())
: MethodInfo(qname, typeof(C), typeof(void), plist, briefHelp, detailedHelp)
{
}
bool isConst() const { return false; }
bool isStatic() const { return true; }
Value invoke(ValueList& args) const
{
throw ProtectedMethodInvocationException();
}
};
template<typename C, typename P0, typename P1, typename P2, typename P3, typename P4, typename P5, typename P6, typename P7>
class StaticProtectedMethodInfo8<C, void, P0, P1, P2, P3, P4, P5, P6, P7>: public MethodInfo
{
public:
StaticProtectedMethodInfo8(const std::string& qname, const ParameterInfoList& plist, std::string briefHelp = std::string(), std::string detailedHelp = std::string())
: MethodInfo(qname, typeof(C), typeof(void), plist, briefHelp, detailedHelp)
{
}
bool isConst() const { return false; }
bool isStatic() const { return true; }
Value invoke(ValueList& args) const
{
throw ProtectedMethodInvocationException();
}
};
template<typename C, typename P0, typename P1, typename P2, typename P3, typename P4, typename P5, typename P6, typename P7, typename P8>
class StaticProtectedMethodInfo9<C, void, P0, P1, P2, P3, P4, P5, P6, P7, P8>: public MethodInfo
{
public:
StaticProtectedMethodInfo9(const std::string& qname, const ParameterInfoList& plist, std::string briefHelp = std::string(), std::string detailedHelp = std::string())
: MethodInfo(qname, typeof(C), typeof(void), plist, briefHelp, detailedHelp)
{
}
bool isConst() const { return false; }
bool isStatic() const { return true; }
Value invoke(ValueList& args) const
{
throw ProtectedMethodInvocationException();
}
};
template<typename C, typename P0, typename P1, typename P2, typename P3, typename P4, typename P5, typename P6, typename P7, typename P8, typename P9>
class StaticProtectedMethodInfo10<C, void, P0, P1, P2, P3, P4, P5, P6, P7, P8, P9>: public MethodInfo
{
public:
StaticProtectedMethodInfo10(const std::string& qname, const ParameterInfoList& plist, std::string briefHelp = std::string(), std::string detailedHelp = std::string())
: MethodInfo(qname, typeof(C), typeof(void), plist, briefHelp, detailedHelp)
{
}
bool isConst() const { return false; }
bool isStatic() const { return true; }
Value invoke(ValueList& args) const
{
throw ProtectedMethodInvocationException();
}
};
template<typename C, typename P0, typename P1, typename P2, typename P3, typename P4, typename P5, typename P6, typename P7, typename P8, typename P9, typename P10>
class StaticProtectedMethodInfo11<C, void, P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10>: public MethodInfo
{
public:
StaticProtectedMethodInfo11(const std::string& qname, const ParameterInfoList& plist, std::string briefHelp = std::string(), std::string detailedHelp = std::string())
: MethodInfo(qname, typeof(C), typeof(void), plist, briefHelp, detailedHelp)
{
}
bool isConst() const { return false; }
bool isStatic() const { return true; }
Value invoke(ValueList& args) const
{
throw ProtectedMethodInvocationException();
}
};
template<typename C, typename P0, typename P1, typename P2, typename P3, typename P4, typename P5, typename P6, typename P7, typename P8, typename P9, typename P10, typename P11>
class StaticProtectedMethodInfo12<C, void, P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11>: public MethodInfo
{
public:
StaticProtectedMethodInfo12(const std::string& qname, const ParameterInfoList& plist, std::string briefHelp = std::string(), std::string detailedHelp = std::string())
: MethodInfo(qname, typeof(C), typeof(void), plist, briefHelp, detailedHelp)
{
}
bool isConst() const { return false; }
bool isStatic() const { return true; }
Value invoke(ValueList& args) const
{
throw ProtectedMethodInvocationException();
}
};
template<typename C, typename P0, typename P1, typename P2, typename P3, typename P4, typename P5, typename P6, typename P7, typename P8, typename P9, typename P10, typename P11, typename P12>
class StaticProtectedMethodInfo13<C, void, P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12>: public MethodInfo
{
public:
StaticProtectedMethodInfo13(const std::string& qname, const ParameterInfoList& plist, std::string briefHelp = std::string(), std::string detailedHelp = std::string())
: MethodInfo(qname, typeof(C), typeof(void), plist, briefHelp, detailedHelp)
{
}
bool isConst() const { return false; }
bool isStatic() const { return true; }
Value invoke(ValueList& args) const
{
throw ProtectedMethodInvocationException();
}
};
template<typename C, typename P0, typename P1, typename P2, typename P3, typename P4, typename P5, typename P6, typename P7, typename P8, typename P9, typename P10, typename P11, typename P12, typename P13>
class StaticProtectedMethodInfo14<C, void, P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13>: public MethodInfo
{
public:
StaticProtectedMethodInfo14(const std::string& qname, const ParameterInfoList& plist, std::string briefHelp = std::string(), std::string detailedHelp = std::string())
: MethodInfo(qname, typeof(C), typeof(void), plist, briefHelp, detailedHelp)
{
}
bool isConst() const { return false; }
bool isStatic() const { return true; }
Value invoke(ValueList& args) const
{
throw ProtectedMethodInvocationException();
}
};
template<typename C, typename P0, typename P1, typename P2, typename P3, typename P4, typename P5, typename P6, typename P7, typename P8, typename P9, typename P10, typename P11, typename P12, typename P13, typename P14>
class StaticProtectedMethodInfo15<C, void, P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14>: public MethodInfo
{
public:
StaticProtectedMethodInfo15(const std::string& qname, const ParameterInfoList& plist, std::string briefHelp = std::string(), std::string detailedHelp = std::string())
: MethodInfo(qname, typeof(C), typeof(void), plist, briefHelp, detailedHelp)
{
}
bool isConst() const { return false; }
bool isStatic() const { return true; }
Value invoke(ValueList& args) const
{
throw ProtectedMethodInvocationException();
}
};
template<typename C, typename P0, typename P1, typename P2, typename P3, typename P4, typename P5, typename P6, typename P7, typename P8, typename P9, typename P10, typename P11, typename P12, typename P13, typename P14, typename P15>
class StaticProtectedMethodInfo16<C, void, P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15>: public MethodInfo
{
public:
StaticProtectedMethodInfo16(const std::string& qname, const ParameterInfoList& plist, std::string briefHelp = std::string(), std::string detailedHelp = std::string())
: MethodInfo(qname, typeof(C), typeof(void), plist, briefHelp, detailedHelp)
{
}
bool isConst() const { return false; }
bool isStatic() const { return true; }
Value invoke(ValueList& args) const
{
throw ProtectedMethodInvocationException();
}
};
}
#endif

26
include/osgIntrospection/Type
View File

@ -65,6 +65,14 @@ namespace osgIntrospection
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();
@ -174,19 +182,19 @@ namespace osgIntrospection
void getPropertiesMap(PropertyInfoMap& props) const;
/// Returns the list of constructors defined for this type.
inline const ConstructorInfoList& getConstructors() const;
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() const;
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) const;
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) const;
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.
@ -278,8 +286,10 @@ namespace osgIntrospection
const Type* _referenced_type;
ConstructorInfoList _cons;
ConstructorInfoList _protected_cons;
PropertyInfoList _props;
MethodInfoList _methods;
MethodInfoList _protected_methods;
EnumLabelMap _labels;
bool _is_defined;
@ -429,16 +439,16 @@ namespace osgIntrospection
return _props;
}
inline const ConstructorInfoList& Type::getConstructors() const
inline const ConstructorInfoList& Type::getConstructors(FunctionCategory category) const
{
check_defined();
return _cons;
return category == PUBLIC_FUNCTIONS ? _cons : _protected_cons;
}
inline const MethodInfoList& Type::getMethods() const
inline const MethodInfoList& Type::getMethods(FunctionCategory category) const
{
check_defined();
return _methods;
return category == PUBLIC_FUNCTIONS ? _methods : _protected_methods;
}
inline bool Type::isPointer() const

927
include/osgIntrospection/TypedMethodInfo
View File

@ -2972,6 +2972,933 @@ namespace osgIntrospection
FunctionType f_;
};
template<typename C, typename R>
class TypedProtectedMethodInfo0: public MethodInfo
{
public:
TypedProtectedMethodInfo0(const std::string& qname, bool isConstMethod, const ParameterInfoList& plist, VirtualState virtualState, std::string briefHelp = std::string(), std::string detailedHelp = std::string())
: MethodInfo(qname, typeof(C), typeof(R), plist, virtualState, briefHelp, detailedHelp), is_const_(isConstMethod)
{
}
static TypedProtectedMethodInfo0 *constMethod(const std::string& qname, const ParameterInfoList& plist, VirtualState virtualState, std::string briefHelp = std::string(), std::string detailedHelp = std::string())
{
return new TypedProtectedMethodInfo0(qname, true, plist, virtualState, briefHelp, detailedHelp);
}
static TypedProtectedMethodInfo0 *nonConstMethod(const std::string& qname, const ParameterInfoList& plist, VirtualState virtualState, std::string briefHelp = std::string(), std::string detailedHelp = std::string())
{
return new TypedProtectedMethodInfo0(qname, false, plist, virtualState, briefHelp, detailedHelp);
}
bool isConst() const { return is_const_; }
bool isStatic() const { return false; }
Value invoke(const Value& /*instance*/, ValueList& /*args*/) const
{
throw ProtectedMethodInvocationException();
}
Value invoke(Value& /*instance*/, ValueList& /*args*/) const
{
throw ProtectedMethodInvocationException();
}
private:
bool is_const_;
};
template<typename C, typename R, typename P0>
class TypedProtectedMethodInfo1: public MethodInfo
{
public:
TypedProtectedMethodInfo1(const std::string& qname, bool isConstMethod, const ParameterInfoList& plist, VirtualState virtualState, std::string briefHelp = std::string(), std::string detailedHelp = std::string())
: MethodInfo(qname, typeof(C), typeof(R), plist, virtualState, briefHelp, detailedHelp), is_const_(isConstMethod)
{
}
bool isConst() const { return is_const_; }
bool isStatic() const { return false; }
Value invoke(const Value& /*instance*/, ValueList& /*args*/) const
{
throw ProtectedMethodInvocationException();
}
Value invoke(Value& /*instance*/, ValueList& /*args*/) const
{
throw ProtectedMethodInvocationException();
}
private:
bool is_const_;
};
template<typename C, typename R, typename P0, typename P1>
class TypedProtectedMethodInfo2: public MethodInfo
{
public:
TypedProtectedMethodInfo2(const std::string& qname, bool isConstMethod, const ParameterInfoList& plist, VirtualState virtualState, std::string briefHelp = std::string(), std::string detailedHelp = std::string())
: MethodInfo(qname, typeof(C), typeof(R), plist, virtualState, briefHelp, detailedHelp), is_const_(isConstMethod)
{
}
bool isConst() const { return is_const_; }
bool isStatic() const { return false; }
Value invoke(const Value& /*instance*/, ValueList& /*args*/) const
{
throw ProtectedMethodInvocationException();
}
Value invoke(Value& /*instance*/, ValueList& /*args*/) const
{
throw ProtectedMethodInvocationException();
}
private:
bool is_const_;
};
template<typename C, typename R, typename P0, typename P1, typename P2>
class TypedProtectedMethodInfo3: public MethodInfo
{
public:
TypedProtectedMethodInfo3(const std::string& qname, bool isConstMethod, const ParameterInfoList& plist, VirtualState virtualState, std::string briefHelp = std::string(), std::string detailedHelp = std::string())
: MethodInfo(qname, typeof(C), typeof(R), plist, virtualState, briefHelp, detailedHelp), is_const_(isConstMethod)
{
}
bool isConst() const { return is_const_; }
bool isStatic() const { return false; }
Value invoke(const Value& /*instance*/, ValueList& /*args*/) const
{
throw ProtectedMethodInvocationException();
}
Value invoke(Value& /*instance*/, ValueList& /*args*/) const
{
throw ProtectedMethodInvocationException();
}
private:
bool is_const_;
};
template<typename C, typename R, typename P0, typename P1, typename P2, typename P3>
class TypedProtectedMethodInfo4: public MethodInfo
{
public:
TypedProtectedMethodInfo4(const std::string& qname, bool isConstMethod, const ParameterInfoList& plist, VirtualState virtualState, std::string briefHelp = std::string(), std::string detailedHelp = std::string())
: MethodInfo(qname, typeof(C), typeof(R), plist, virtualState, briefHelp, detailedHelp), is_const_(isConstMethod)
{
}
bool isConst() const { return is_const_; }
bool isStatic() const { return false; }
Value invoke(const Value& /*instance*/, ValueList& /*args*/) const
{
throw ProtectedMethodInvocationException();
}
Value invoke(Value& /*instance*/, ValueList& /*args*/) const
{
throw ProtectedMethodInvocationException();
}
private:
bool is_const_;
};
template<typename C, typename R, typename P0, typename P1, typename P2, typename P3, typename P4>
class TypedProtectedMethodInfo5: public MethodInfo
{
public:
TypedProtectedMethodInfo5(const std::string& qname, bool isConstMethod, const ParameterInfoList& plist, VirtualState virtualState, std::string briefHelp = std::string(), std::string detailedHelp = std::string())
: MethodInfo(qname, typeof(C), typeof(R), plist, virtualState, briefHelp, detailedHelp), is_const_(isConstMethod)
{
}
bool isConst() const { return is_const_; }
bool isStatic() const { return false; }
Value invoke(const Value& /*instance*/, ValueList& /*args*/) const
{
throw ProtectedMethodInvocationException();
}
Value invoke(Value& /*instance*/, ValueList& /*args*/) const
{
throw ProtectedMethodInvocationException();
}
private:
bool is_const_;
};
template<typename C, typename R, typename P0, typename P1, typename P2, typename P3, typename P4, typename P5>
class TypedProtectedMethodInfo6: public MethodInfo
{
public:
TypedProtectedMethodInfo6(const std::string& qname, bool isConstMethod, const ParameterInfoList& plist, VirtualState virtualState, std::string briefHelp = std::string(), std::string detailedHelp = std::string())
: MethodInfo(qname, typeof(C), typeof(R), plist, virtualState, briefHelp, detailedHelp), is_const_(isConstMethod)
{
}
bool isConst() const { return is_const_; }
bool isStatic() const { return false; }
Value invoke(const Value& /*instance*/, ValueList& /*args*/) const
{
throw ProtectedMethodInvocationException();
}
Value invoke(Value& /*instance*/, ValueList& /*args*/) const
{
throw ProtectedMethodInvocationException();
}
private:
bool is_const_;
};
template<typename C, typename R, typename P0, typename P1, typename P2, typename P3, typename P4, typename P5, typename P6>
class TypedProtectedMethodInfo7: public MethodInfo
{
public:
TypedProtectedMethodInfo7(const std::string& qname, bool isConstMethod, const ParameterInfoList& plist, VirtualState virtualState, std::string briefHelp = std::string(), std::string detailedHelp = std::string())
: MethodInfo(qname, typeof(C), typeof(R), plist, virtualState, briefHelp, detailedHelp), is_const_(isConstMethod)
{
}
bool isConst() const { return is_const_; }
bool isStatic() const { return false; }
Value invoke(const Value& /*instance*/, ValueList& /*args*/) const
{
throw ProtectedMethodInvocationException();
}
Value invoke(Value& /*instance*/, ValueList& /*args*/) const
{
throw ProtectedMethodInvocationException();
}
private:
bool is_const_;
};
template<typename C, typename R, typename P0, typename P1, typename P2, typename P3, typename P4, typename P5, typename P6, typename P7>
class TypedProtectedMethodInfo8: public MethodInfo
{
public:
TypedProtectedMethodInfo8(const std::string& qname, bool isConstMethod, const ParameterInfoList& plist, VirtualState virtualState, std::string briefHelp = std::string(), std::string detailedHelp = std::string())
: MethodInfo(qname, typeof(C), typeof(R), plist, virtualState, briefHelp, detailedHelp), is_const_(isConstMethod)
{
}
bool isConst() const { return is_const_; }
bool isStatic() const { return false; }
Value invoke(const Value& /*instance*/, ValueList& /*args*/) const
{
throw ProtectedMethodInvocationException();
}
Value invoke(Value& /*instance*/, ValueList& /*args*/) const
{
throw ProtectedMethodInvocationException();
}
private:
bool is_const_;
};
template<typename C, typename R, typename P0, typename P1, typename P2, typename P3, typename P4, typename P5, typename P6, typename P7, typename P8>
class TypedProtectedMethodInfo9: public MethodInfo
{
public:
TypedProtectedMethodInfo9(const std::string& qname, bool isConstMethod, const ParameterInfoList& plist, VirtualState virtualState, std::string briefHelp = std::string(), std::string detailedHelp = std::string())
: MethodInfo(qname, typeof(C), typeof(R), plist, virtualState, briefHelp, detailedHelp), is_const_(isConstMethod)
{
}
bool isConst() const { return is_const_; }
bool isStatic() const { return false; }
Value invoke(const Value& /*instance*/, ValueList& /*args*/) const
{
throw ProtectedMethodInvocationException();
}
Value invoke(Value& /*instance*/, ValueList& /*args*/) const
{
throw ProtectedMethodInvocationException();
}
private:
bool is_const_;
};
template<typename C, typename R, typename P0, typename P1, typename P2, typename P3, typename P4, typename P5, typename P6, typename P7, typename P8, typename P9>
class TypedProtectedMethodInfo10: public MethodInfo
{
public:
TypedProtectedMethodInfo10(const std::string& qname, bool isConstMethod, const ParameterInfoList& plist, VirtualState virtualState, std::string briefHelp = std::string(), std::string detailedHelp = std::string())
: MethodInfo(qname, typeof(C), typeof(R), plist, virtualState, briefHelp, detailedHelp), is_const_(isConstMethod)
{
}
bool isConst() const { return is_const_; }
bool isStatic() const { return false; }
Value invoke(const Value& /*instance*/, ValueList& /*args*/) const
{
throw ProtectedMethodInvocationException();
}
Value invoke(Value& /*instance*/, ValueList& /*args*/) const
{
throw ProtectedMethodInvocationException();
}
private:
bool is_const_;
};
template<typename C, typename R, typename P0, typename P1, typename P2, typename P3, typename P4, typename P5, typename P6, typename P7, typename P8, typename P9, typename P10>
class TypedProtectedMethodInfo11: public MethodInfo
{
public:
TypedProtectedMethodInfo11(const std::string& qname, bool isConstMethod, const ParameterInfoList& plist, VirtualState virtualState, std::string briefHelp = std::string(), std::string detailedHelp = std::string())
: MethodInfo(qname, typeof(C), typeof(R), plist, virtualState, briefHelp, detailedHelp), is_const_(isConstMethod)
{
}
bool isConst() const { return is_const_; }
bool isStatic() const { return false; }
Value invoke(const Value& /*instance*/, ValueList& /*args*/) const
{
throw ProtectedMethodInvocationException();
}
Value invoke(Value& /*instance*/, ValueList& /*args*/) const
{
throw ProtectedMethodInvocationException();
}
private:
bool is_const_;
};
template<typename C, typename R, typename P0, typename P1, typename P2, typename P3, typename P4, typename P5, typename P6, typename P7, typename P8, typename P9, typename P10, typename P11>
class TypedProtectedMethodInfo12: public MethodInfo
{
public:
TypedProtectedMethodInfo12(const std::string& qname, bool isConstMethod, const ParameterInfoList& plist, VirtualState virtualState, std::string briefHelp = std::string(), std::string detailedHelp = std::string())
: MethodInfo(qname, typeof(C), typeof(R), plist, virtualState, briefHelp, detailedHelp), is_const_(isConstMethod)
{
}
bool isConst() const { return is_const_; }
bool isStatic() const { return false; }
Value invoke(const Value& /*instance*/, ValueList& /*args*/) const
{
throw ProtectedMethodInvocationException();
}
Value invoke(Value& /*instance*/, ValueList& /*args*/) const
{
throw ProtectedMethodInvocationException();
}
private:
bool is_const_;
};
template<typename C, typename R, typename P0, typename P1, typename P2, typename P3, typename P4, typename P5, typename P6, typename P7, typename P8, typename P9, typename P10, typename P11, typename P12>
class TypedProtectedMethodInfo13: public MethodInfo
{
public:
TypedProtectedMethodInfo13(const std::string& qname, bool isConstMethod, const ParameterInfoList& plist, VirtualState virtualState, std::string briefHelp = std::string(), std::string detailedHelp = std::string())
: MethodInfo(qname, typeof(C), typeof(R), plist, virtualState, briefHelp, detailedHelp), is_const_(isConstMethod)
{
}
bool isConst() const { return is_const_; }
bool isStatic() const { return false; }
Value invoke(const Value& /*instance*/, ValueList& /*args*/) const
{
throw ProtectedMethodInvocationException();
}
Value invoke(Value& /*instance*/, ValueList& /*args*/) const
{
throw ProtectedMethodInvocationException();
}
private:
bool is_const_;
};
template<typename C, typename R, typename P0, typename P1, typename P2, typename P3, typename P4, typename P5, typename P6, typename P7, typename P8, typename P9, typename P10, typename P11, typename P12, typename P13>
class TypedProtectedMethodInfo14: public MethodInfo
{
public:
TypedProtectedMethodInfo14(const std::string& qname, bool isConstMethod, const ParameterInfoList& plist, VirtualState virtualState, std::string briefHelp = std::string(), std::string detailedHelp = std::string())
: MethodInfo(qname, typeof(C), typeof(R), plist, virtualState, briefHelp, detailedHelp), is_const_(isConstMethod)
{
}
bool isConst() const { return is_const_; }
bool isStatic() const { return false; }
Value invoke(const Value& /*instance*/, ValueList& /*args*/) const
{
throw ProtectedMethodInvocationException();
}
Value invoke(Value& /*instance*/, ValueList& /*args*/) const
{
throw ProtectedMethodInvocationException();
}
private:
bool is_const_;
};
template<typename C, typename R, typename P0, typename P1, typename P2, typename P3, typename P4, typename P5, typename P6, typename P7, typename P8, typename P9, typename P10, typename P11, typename P12, typename P13, typename P14>
class TypedProtectedMethodInfo15: public MethodInfo
{
public:
TypedProtectedMethodInfo15(const std::string& qname, bool isConstMethod, const ParameterInfoList& plist, VirtualState virtualState, std::string briefHelp = std::string(), std::string detailedHelp = std::string())
: MethodInfo(qname, typeof(C), typeof(R), plist, virtualState, briefHelp, detailedHelp), is_const_(isConstMethod)
{
}
bool isConst() const { return is_const_; }
bool isStatic() const { return false; }
Value invoke(const Value& /*instance*/, ValueList& /*args*/) const
{
throw ProtectedMethodInvocationException();
}
Value invoke(Value& /*instance*/, ValueList& /*args*/) const
{
throw ProtectedMethodInvocationException();
}
private:
bool is_const_;
};
template<typename C, typename R, typename P0, typename P1, typename P2, typename P3, typename P4, typename P5, typename P6, typename P7, typename P8, typename P9, typename P10, typename P11, typename P12, typename P13, typename P14, typename P15>
class TypedProtectedMethodInfo16: public MethodInfo
{
public:
TypedProtectedMethodInfo16(const std::string& qname, bool isConstMethod, const ParameterInfoList& plist, VirtualState virtualState, std::string briefHelp = std::string(), std::string detailedHelp = std::string())
: MethodInfo(qname, typeof(C), typeof(R), plist, virtualState, briefHelp, detailedHelp), is_const_(isConstMethod)
{
}
bool isConst() const { return is_const_; }
bool isStatic() const { return false; }
Value invoke(const Value& /*instance*/, ValueList& /*args*/) const
{
throw ProtectedMethodInvocationException();
}
Value invoke(Value& /*instance*/, ValueList& /*args*/) const
{
throw ProtectedMethodInvocationException();
}
private:
bool is_const_;
};
template<typename C>
class TypedProtectedMethodInfo0<C, void>: public MethodInfo
{
public:
TypedProtectedMethodInfo0(const std::string& qname, bool isConstMethod, const ParameterInfoList& plist, VirtualState virtualState, std::string briefHelp = std::string(), std::string detailedHelp = std::string())
: MethodInfo(qname, typeof(C), typeof(void), plist, virtualState, briefHelp, detailedHelp), is_const_(isConstMethod)
{
}
bool isConst() const { return is_const_; }
bool isStatic() const { return false; }
Value invoke(const Value& /*instance*/, ValueList& /*args*/) const
{
throw ProtectedMethodInvocationException();
}
Value invoke(Value& /*instance*/, ValueList& /*args*/) const
{
throw ProtectedMethodInvocationException();
}
private:
bool is_const_;
};
template<typename C, typename P0>
class TypedProtectedMethodInfo1<C, void, P0>: public MethodInfo
{
public:
TypedProtectedMethodInfo1(const std::string& qname, bool isConstMethod, const ParameterInfoList& plist, VirtualState virtualState, std::string briefHelp = std::string(), std::string detailedHelp = std::string())
: MethodInfo(qname, typeof(C), typeof(void), plist, virtualState, briefHelp, detailedHelp), is_const_(isConstMethod)
{
}
bool isConst() const { return is_const_; }
bool isStatic() const { return false; }
Value invoke(const Value& /*instance*/, ValueList& /*args*/) const
{
throw ProtectedMethodInvocationException();
}
Value invoke(Value& /*instance*/, ValueList& /*args*/) const
{
throw ProtectedMethodInvocationException();
}
private:
bool is_const_;
};
template<typename C, typename P0, typename P1>
class TypedProtectedMethodInfo2<C, void, P0, P1>: public MethodInfo
{
public:
TypedProtectedMethodInfo2(const std::string& qname, bool isConstMethod, const ParameterInfoList& plist, VirtualState virtualState, std::string briefHelp = std::string(), std::string detailedHelp = std::string())
: MethodInfo(qname, typeof(C), typeof(void), plist, virtualState, briefHelp, detailedHelp), is_const_(isConstMethod)
{
}
bool isConst() const { return is_const_; }
bool isStatic() const { return false; }
Value invoke(const Value& /*instance*/, ValueList& /*args*/) const
{
throw ProtectedMethodInvocationException();
}
Value invoke(Value& /*instance*/, ValueList& /*args*/) const
{
throw ProtectedMethodInvocationException();
}
private:
bool is_const_;
};
template<typename C, typename P0, typename P1, typename P2>
class TypedProtectedMethodInfo3<C, void, P0, P1, P2>: public MethodInfo
{
public:
TypedProtectedMethodInfo3(const std::string& qname, bool isConstMethod, const ParameterInfoList& plist, VirtualState virtualState, std::string briefHelp = std::string(), std::string detailedHelp = std::string())
: MethodInfo(qname, typeof(C), typeof(void), plist, virtualState, briefHelp, detailedHelp), is_const_(isConstMethod)
{
}
bool isConst() const { return is_const_; }
bool isStatic() const { return false; }
Value invoke(const Value& /*instance*/, ValueList& /*args*/) const
{
throw ProtectedMethodInvocationException();
}
Value invoke(Value& /*instance*/, ValueList& /*args*/) const
{
throw ProtectedMethodInvocationException();
}
private:
bool is_const_;
};
template<typename C, typename P0, typename P1, typename P2, typename P3>
class TypedProtectedMethodInfo4<C, void, P0, P1, P2, P3>: public MethodInfo
{
public:
TypedProtectedMethodInfo4(const std::string& qname, bool isConstMethod, const ParameterInfoList& plist, VirtualState virtualState, std::string briefHelp = std::string(), std::string detailedHelp = std::string())
: MethodInfo(qname, typeof(C), typeof(void), plist, virtualState, briefHelp, detailedHelp), is_const_(isConstMethod)
{
}
bool isConst() const { return is_const_; }
bool isStatic() const { return false; }
Value invoke(const Value& /*instance*/, ValueList& /*args*/) const
{
throw ProtectedMethodInvocationException();
}
Value invoke(Value& /*instance*/, ValueList& /*args*/) const
{
throw ProtectedMethodInvocationException();
}
private:
bool is_const_;
};
template<typename C, typename P0, typename P1, typename P2, typename P3, typename P4>
class TypedProtectedMethodInfo5<C, void, P0, P1, P2, P3, P4>: public MethodInfo
{
public:
TypedProtectedMethodInfo5(const std::string& qname, bool isConstMethod, const ParameterInfoList& plist, VirtualState virtualState, std::string briefHelp = std::string(), std::string detailedHelp = std::string())
: MethodInfo(qname, typeof(C), typeof(void), plist, virtualState, briefHelp, detailedHelp), is_const_(isConstMethod)
{
}
bool isConst() const { return is_const_; }
bool isStatic() const { return false; }
Value invoke(const Value& /*instance*/, ValueList& /*args*/) const
{
throw ProtectedMethodInvocationException();
}
Value invoke(Value& /*instance*/, ValueList& /*args*/) const
{
throw ProtectedMethodInvocationException();
}
private:
bool is_const_;
};
template<typename C, typename P0, typename P1, typename P2, typename P3, typename P4, typename P5>
class TypedProtectedMethodInfo6<C, void, P0, P1, P2, P3, P4, P5>: public MethodInfo
{
public:
TypedProtectedMethodInfo6(const std::string& qname, bool isConstMethod, const ParameterInfoList& plist, VirtualState virtualState, std::string briefHelp = std::string(), std::string detailedHelp = std::string())
: MethodInfo(qname, typeof(C), typeof(void), plist, virtualState, briefHelp, detailedHelp), is_const_(isConstMethod)
{
}
bool isConst() const { return is_const_; }
bool isStatic() const { return false; }
Value invoke(const Value& /*instance*/, ValueList& /*args*/) const
{
throw ProtectedMethodInvocationException();
}
Value invoke(Value& /*instance*/, ValueList& /*args*/) const
{
throw ProtectedMethodInvocationException();
}
private:
bool is_const_;
};
template<typename C, typename P0, typename P1, typename P2, typename P3, typename P4, typename P5, typename P6>
class TypedProtectedMethodInfo7<C, void, P0, P1, P2, P3, P4, P5, P6>: public MethodInfo
{
public:
TypedProtectedMethodInfo7(const std::string& qname, bool isConstMethod, const ParameterInfoList& plist, VirtualState virtualState, std::string briefHelp = std::string(), std::string detailedHelp = std::string())
: MethodInfo(qname, typeof(C), typeof(void), plist, virtualState, briefHelp, detailedHelp), is_const_(isConstMethod)
{
}
bool isConst() const { return is_const_; }
bool isStatic() const { return false; }
Value invoke(const Value& /*instance*/, ValueList& /*args*/) const
{
throw ProtectedMethodInvocationException();
}
Value invoke(Value& /*instance*/, ValueList& /*args*/) const
{
throw ProtectedMethodInvocationException();
}
private:
bool is_const_;
};
template<typename C, typename P0, typename P1, typename P2, typename P3, typename P4, typename P5, typename P6, typename P7>
class TypedProtectedMethodInfo8<C, void, P0, P1, P2, P3, P4, P5, P6, P7>: public MethodInfo
{
public:
TypedProtectedMethodInfo8(const std::string& qname, bool isConstMethod, const ParameterInfoList& plist, VirtualState virtualState, std::string briefHelp = std::string(), std::string detailedHelp = std::string())
: MethodInfo(qname, typeof(C), typeof(void), plist, virtualState, briefHelp, detailedHelp), is_const_(isConstMethod)
{
}
bool isConst() const { return is_const_; }
bool isStatic() const { return false; }
Value invoke(const Value& /*instance*/, ValueList& /*args*/) const
{
throw ProtectedMethodInvocationException();
}
Value invoke(Value& /*instance*/, ValueList& /*args*/) const
{
throw ProtectedMethodInvocationException();
}
private:
bool is_const_;
};
template<typename C, typename P0, typename P1, typename P2, typename P3, typename P4, typename P5, typename P6, typename P7, typename P8>
class TypedProtectedMethodInfo9<C, void, P0, P1, P2, P3, P4, P5, P6, P7, P8>: public MethodInfo
{
public:
TypedProtectedMethodInfo9(const std::string& qname, bool isConstMethod, const ParameterInfoList& plist, VirtualState virtualState, std::string briefHelp = std::string(), std::string detailedHelp = std::string())
: MethodInfo(qname, typeof(C), typeof(void), plist, virtualState, briefHelp, detailedHelp), is_const_(isConstMethod)
{
}
bool isConst() const { return is_const_; }
bool isStatic() const { return false; }
Value invoke(const Value& /*instance*/, ValueList& /*args*/) const
{
throw ProtectedMethodInvocationException();
}
Value invoke(Value& /*instance*/, ValueList& /*args*/) const
{
throw ProtectedMethodInvocationException();
}
private:
bool is_const_;
};
template<typename C, typename P0, typename P1, typename P2, typename P3, typename P4, typename P5, typename P6, typename P7, typename P8, typename P9>
class TypedProtectedMethodInfo10<C, void, P0, P1, P2, P3, P4, P5, P6, P7, P8, P9>: public MethodInfo
{
public:
TypedProtectedMethodInfo10(const std::string& qname, bool isConstMethod, const ParameterInfoList& plist, VirtualState virtualState, std::string briefHelp = std::string(), std::string detailedHelp = std::string())
: MethodInfo(qname, typeof(C), typeof(void), plist, virtualState, briefHelp, detailedHelp), is_const_(isConstMethod)
{
}
bool isConst() const { return is_const_; }
bool isStatic() const { return false; }
Value invoke(const Value& /*instance*/, ValueList& /*args*/) const
{
throw ProtectedMethodInvocationException();
}
Value invoke(Value& /*instance*/, ValueList& /*args*/) const
{
throw ProtectedMethodInvocationException();
}
private:
bool is_const_;
};
template<typename C, typename P0, typename P1, typename P2, typename P3, typename P4, typename P5, typename P6, typename P7, typename P8, typename P9, typename P10>
class TypedProtectedMethodInfo11<C, void, P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10>: public MethodInfo
{
public:
TypedProtectedMethodInfo11(const std::string& qname, bool isConstMethod, const ParameterInfoList& plist, VirtualState virtualState, std::string briefHelp = std::string(), std::string detailedHelp = std::string())
: MethodInfo(qname, typeof(C), typeof(void), plist, virtualState, briefHelp, detailedHelp), is_const_(isConstMethod)
{
}
bool isConst() const { return is_const_; }
bool isStatic() const { return false; }
Value invoke(const Value& /*instance*/, ValueList& /*args*/) const
{
throw ProtectedMethodInvocationException();
}
Value invoke(Value& /*instance*/, ValueList& /*args*/) const
{
throw ProtectedMethodInvocationException();
}
private:
bool is_const_;
};
template<typename C, typename P0, typename P1, typename P2, typename P3, typename P4, typename P5, typename P6, typename P7, typename P8, typename P9, typename P10, typename P11>
class TypedProtectedMethodInfo12<C, void, P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11>: public MethodInfo
{
public:
TypedProtectedMethodInfo12(const std::string& qname, bool isConstMethod, const ParameterInfoList& plist, VirtualState virtualState, std::string briefHelp = std::string(), std::string detailedHelp = std::string())
: MethodInfo(qname, typeof(C), typeof(void), plist, virtualState, briefHelp, detailedHelp), is_const_(isConstMethod)
{
}
bool isConst() const { return is_const_; }
bool isStatic() const { return false; }
Value invoke(const Value& /*instance*/, ValueList& /*args*/) const
{
throw ProtectedMethodInvocationException();
}
Value invoke(Value& /*instance*/, ValueList& /*args*/) const
{
throw ProtectedMethodInvocationException();
}
private:
bool is_const_;
};
template<typename C, typename P0, typename P1, typename P2, typename P3, typename P4, typename P5, typename P6, typename P7, typename P8, typename P9, typename P10, typename P11, typename P12>
class TypedProtectedMethodInfo13<C, void, P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12>: public MethodInfo
{
public:
TypedProtectedMethodInfo13(const std::string& qname, bool isConstMethod, const ParameterInfoList& plist, VirtualState virtualState, std::string briefHelp = std::string(), std::string detailedHelp = std::string())
: MethodInfo(qname, typeof(C), typeof(void), plist, virtualState, briefHelp, detailedHelp), is_const_(isConstMethod)
{
}
bool isConst() const { return is_const_; }
bool isStatic() const { return false; }
Value invoke(const Value& /*instance*/, ValueList& /*args*/) const
{
throw ProtectedMethodInvocationException();
}
Value invoke(Value& /*instance*/, ValueList& /*args*/) const
{
throw ProtectedMethodInvocationException();
}
private:
bool is_const_;
};
template<typename C, typename P0, typename P1, typename P2, typename P3, typename P4, typename P5, typename P6, typename P7, typename P8, typename P9, typename P10, typename P11, typename P12, typename P13>
class TypedProtectedMethodInfo14<C, void, P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13>: public MethodInfo
{
public:
TypedProtectedMethodInfo14(const std::string& qname, bool isConstMethod, const ParameterInfoList& plist, VirtualState virtualState, std::string briefHelp = std::string(), std::string detailedHelp = std::string())
: MethodInfo(qname, typeof(C), typeof(void), plist, virtualState, briefHelp, detailedHelp), is_const_(isConstMethod)
{
}
bool isConst() const { return is_const_; }
bool isStatic() const { return false; }
Value invoke(const Value& /*instance*/, ValueList& /*args*/) const
{
throw ProtectedMethodInvocationException();
}
Value invoke(Value& /*instance*/, ValueList& /*args*/) const
{
throw ProtectedMethodInvocationException();
}
private:
bool is_const_;
};
template<typename C, typename P0, typename P1, typename P2, typename P3, typename P4, typename P5, typename P6, typename P7, typename P8, typename P9, typename P10, typename P11, typename P12, typename P13, typename P14>
class TypedProtectedMethodInfo15<C, void, P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14>: public MethodInfo
{
public:
TypedProtectedMethodInfo15(const std::string& qname, bool isConstMethod, const ParameterInfoList& plist, VirtualState virtualState, std::string briefHelp = std::string(), std::string detailedHelp = std::string())
: MethodInfo(qname, typeof(C), typeof(void), plist, virtualState, briefHelp, detailedHelp), is_const_(isConstMethod)
{
}
bool isConst() const { return is_const_; }
bool isStatic() const { return false; }
Value invoke(const Value& /*instance*/, ValueList& /*args*/) const
{
throw ProtectedMethodInvocationException();
}
Value invoke(Value& /*instance*/, ValueList& /*args*/) const
{
throw ProtectedMethodInvocationException();
}
private:
bool is_const_;
};
template<typename C, typename P0, typename P1, typename P2, typename P3, typename P4, typename P5, typename P6, typename P7, typename P8, typename P9, typename P10, typename P11, typename P12, typename P13, typename P14, typename P15>
class TypedProtectedMethodInfo16<C, void, P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15>: public MethodInfo
{
public:
TypedProtectedMethodInfo16(const std::string& qname, bool isConstMethod, const ParameterInfoList& plist, VirtualState virtualState, std::string briefHelp = std::string(), std::string detailedHelp = std::string())
: MethodInfo(qname, typeof(C), typeof(void), plist, virtualState, briefHelp, detailedHelp), is_const_(isConstMethod)
{
}
bool isConst() const { return is_const_; }
bool isStatic() const { return false; }
Value invoke(const Value& /*instance*/, ValueList& /*args*/) const
{
throw ProtectedMethodInvocationException();
}
Value invoke(Value& /*instance*/, ValueList& /*args*/) const
{
throw ProtectedMethodInvocationException();
}
private:
bool is_const_;
};
}
#endif

9
src/osgIntrospection/Type.cpp
View File

@ -217,20 +217,21 @@ void Type::getPropertiesMap(PropertyInfoMap& props) const
}
}
void Type::getAllMethods(MethodInfoList& methods) const
void Type::getAllMethods(MethodInfoList& methods, FunctionCategory category) const
{
check_defined();
std::copy(_methods.begin(), _methods.end(), std::back_inserter(methods));
const MethodInfoList& input_methods = (category == PUBLIC_FUNCTIONS ? _methods : _protected_methods);
std::copy(input_methods.begin(), input_methods.end(), std::back_inserter(methods));
for (TypeList::const_iterator i=_base.begin(); i!=_base.end(); ++i)
{
(*i)->getAllMethods(methods);
}
}
void Type::getMethodsMap(MethodInfoMap& methods) const
void Type::getMethodsMap(MethodInfoMap& methods, FunctionCategory category) const
{
check_defined();
methods[this] = _methods;
methods[this] = (category == PUBLIC_FUNCTIONS ? _methods : _protected_methods);
for (TypeList::const_iterator i=_base.begin(); i!=_base.end(); ++i)
{
(*i)->getMethodsMap(methods);