// 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_; }