// One of the core methods of PyOpenNI:
// It tries to find the exposed class that best matches the given node.
BP::object wrapNode(XnNodeHandle node) {
if (node == NULL) {
return BP::object();
}
XnNodeInfo* info = xnGetNodeInfo(node);
const XnProductionNodeDescription* desc = xnNodeInfoGetDescription(info);
XnProductionNodeType original = desc->Type;
if (isInstanceOf(original, XN_NODE_TYPE_PRODUCTION_NODE)) {
if (isInstanceOf(original, XN_NODE_TYPE_GENERATOR)) {
if (isInstanceOf(original, XN_NODE_TYPE_MAP_GENERATOR)) {
if (isInstanceOf(original, XN_NODE_TYPE_DEPTH)) {
return BP::object(xn::DepthGenerator(node));
}
if (isInstanceOf(original, XN_NODE_TYPE_IMAGE)) {
return BP::object(xn::ImageGenerator(node));
}
if (isInstanceOf(original, XN_NODE_TYPE_SCENE)) {
return BP::object(xn::SceneAnalyzer(node));
}
return BP::object(xn::MapGenerator(node));
}
if (isInstanceOf(original, XN_NODE_TYPE_GESTURE)) {
return BP::object(xn::GestureGenerator(node));
}
if (isInstanceOf(original, XN_NODE_TYPE_USER)) {
return BP::object(xn::UserGenerator(node));
}
if (isInstanceOf(original, XN_NODE_TYPE_AUDIO)) {
return BP::object(xn::AudioGenerator(node));
}
return BP::object(xn::Generator(node));
}
return BP::object(xn::ProductionNode(node));
}
//This should never happen
PyErr_SetString(PyExc_TypeError, "Couldn't find appropiate type to wrap node.");
throw BP::error_already_set();
}
xplat::module::CxxModule::Provider ModuleHolder::getProvider() const {
return [self=jni::make_global(self())] {
static auto method =
ModuleHolder::javaClassStatic()->getMethod<JNativeModule::javaobject()>(
"getModule");
// This is the call which uses the lazy Java Provider to instantiate the
// Java CxxModuleWrapper which contains the CxxModule.
auto module = method(self);
CHECK(module->isInstanceOf(CxxModuleWrapperBase::javaClassStatic()))
<< "module isn't a C++ module";
auto cxxModule = jni::static_ref_cast<CxxModuleWrapperBase::javaobject>(module);
// Then, we grab the CxxModule from the wrapper, which is no longer needed.
return cxxModule->cthis()->getModule();
};
}
/*static*/ HuntCrossleyContact&
HuntCrossleyContact::updDowncast(ForceSubsystem& s) {
assert(isInstanceOf(s));
return static_cast<HuntCrossleyContact&>(s);
}
/*static*/ const HuntCrossleyContact&
HuntCrossleyContact::downcast(const ForceSubsystem& s) {
assert(isInstanceOf(s));
return static_cast<const HuntCrossleyContact&>(s);
}
/*static*/ GeneralForceSubsystem&
GeneralForceSubsystem::updDowncast(ForceSubsystem& s) {
assert(isInstanceOf(s));
return static_cast<GeneralForceSubsystem&>(s);
}
/*static*/ const GeneralForceSubsystem&
GeneralForceSubsystem::downcast(const ForceSubsystem& s) {
assert(isInstanceOf(s));
return static_cast<const GeneralForceSubsystem&>(s);
}
Body::Massless& Body::Massless::updDowncast(Body& b) {
assert(isInstanceOf(b));
return static_cast<Massless&>(b);
}
const Body::Massless& Body::Massless::downcast(const Body& b) {
assert(isInstanceOf(b));
return static_cast<const Massless&>(b);
}
Body::Ground& Body::Ground::updDowncast(Body& b) {
assert(isInstanceOf(b));
return static_cast<Ground&>(b);
}
const Body::Ground& Body::Ground::downcast(const Body& b) {
assert(isInstanceOf(b));
return static_cast<const Ground&>(b);
}
Body::Rigid& Body::Rigid::updDowncast(Body& b) {
assert(isInstanceOf(b));
return static_cast<Rigid&>(b);
}
const Body::Rigid& Body::Rigid::downcast(const Body& b) {
assert(isInstanceOf(b));
return static_cast<const Rigid&>(b);
}
/*static*/ Decorations&
Decorations::updDowncast(DecorativeGeometry& s) {
assert(isInstanceOf(s));
return static_cast<Decorations&>(s);
}
/*static*/ const Decorations&
Decorations::downcast(const DecorativeGeometry& s) {
assert(isInstanceOf(s));
return static_cast<const Decorations&>(s);
}
bool Documento::isInstanceOf(const Documento& documento) const
{
return isInstanceOf(documento.getTipo());
}
bool Documento::operator ==(const Documento& documento)
{
return isInstanceOf(documento) && numero_ == documento.numero_;
}
