Mesh* createMeshFromResource(const std::string& resource, const Eigen::Vector3d &scale) { resource_retriever::Retriever retriever; resource_retriever::MemoryResource res; try { res = retriever.get(resource); } catch (resource_retriever::Exception& e) { logError("%s", e.what()); return NULL; } if (res.size == 0) { logWarn("Retrieved empty mesh for resource '%s'", resource.c_str()); return NULL; } Mesh *m = createMeshFromBinary(reinterpret_cast<const char*>(res.data.get()), res.size, scale, resource); if (!m) logWarn("Assimp reports no scene in %s", resource.c_str()); return m; }
void DisplayClient::appClientReceiveMulticast(int servicePort, SYNTRO_EHEAD *multiCast, int len) { // make sure this is for us if (servicePort != m_receivePort) { logWarn(QString("Multicast received to invalid port %1").arg(servicePort)); free(multiCast); return; } // and the size we expect if (len != (sizeof(SYNTRO_RECORD_HEADER) + sizeof(quint32))) { logWarn(QString("Multicast length is unexpected : %1").arg(len - sizeof(SYNTRO_RECORD_HEADER))); free(multiCast); return; } // unpack the record, first get a pointer to the SYNTRO_RECORD_HEADER SYNTRO_RECORD_HEADER *head = (SYNTRO_RECORD_HEADER *)(multiCast + 1); // the led data is immediately after the SYNTRO_RECORD_HEADER in a single quint32 quint32 *values = (quint32 *)(head + 1); // the BoneLedDisplay class catches this signal emit newData(*values); // ack the data clientSendMulticastAck(servicePort); // always free the record you are given free(multiCast); }
bool shares_reload() { pthread_mutex_lock(&shareMutex); int fd; char* shareFilename = shareList->shareFile; char line[PATH_MAX]; logDebug("share reload"); if (shareFilename == NULL) { logWarn("There is no share list to reload"); pthread_mutex_unlock(&shareMutex); return false; } if (!fs_exist(shareFilename)) { logWarn("The share list file '%s' do not exist", shareFilename); pthread_mutex_unlock(&shareMutex); return false; } shares_clearList(); fd = file_open(shareFilename); while (file_readLine(fd, line)) { shares_parse(line); } pthread_mutex_unlock(&shareMutex); return true; }
bool ini_addSection(Ini* ini, const char* sectionName) { if (ini == NULL) { logWarn("Invalid ini object"); return false; } if (sectionName == NULL) { logWarn("Section name is NULL"); return false; } if (ini_get(ini, sectionName) != NULL) { logWarn("Section '%s' already exist", sectionName); return false; } Section* section = memory_new(Section, true); str_ncpy(section->name, sectionName, sizeof(section->name)); section->keys = list_new(true); section->values = list_new(true); list_add(ini->sections, (Any)section); return true; }
void PeerAdmin::processServer(ServerSocketChannelPtr socket, SharedPtr< Peer::Factory > factory) { try { SocketChannelPtr clientSocket = socket->accept(); clientSocket->registerTo(m_selector, SelectionKey::OP_READ, factory->build(clientSocket)); } catch (Exception &e) { logWarn() << __demangle(typeid(*this).name()) << " Close peer connection after throwing an instance of '" << __demangle(typeid(e).name()) << "'"; if (!e.message().isEmpty()) logWarn() << " what(): " << e.message(); } socket->registerTo(m_selector, SelectionKey::OP_READ, factory); }
kinematic_constraints::ConstraintEvaluationResult kinematic_constraints::JointConstraint::decide(const robot_state::RobotState &state, bool verbose) const { if (!joint_model_) return ConstraintEvaluationResult(true, 0.0); const robot_state::JointState *joint = state.getJointState(joint_model_->getName()); if (!joint) { logWarn("No joint in state with name '%s'", joint_model_->getName().c_str()); return ConstraintEvaluationResult(true, 0.0); } double current_joint_position = joint->getVariableValues()[0]; if (!local_variable_name_.empty()) { const std::map<std::string, unsigned int> &index_map = joint->getVariableIndexMap(); std::map<std::string, unsigned int>::const_iterator it = index_map.find(joint_variable_name_); if (it == index_map.end()) { logWarn("Local name '%s' is not known to joint state with name '%s'", local_variable_name_.c_str(), joint_model_->getName().c_str()); return ConstraintEvaluationResult(true, 0.0); } else current_joint_position = joint->getVariableValues()[it->second]; } double dif = 0.0; // compute signed shortest distance for continuous joints if (joint_is_continuous_) { dif = normalizeAngle(current_joint_position) - joint_position_; if (dif > boost::math::constants::pi<double>()) dif = 2.0*boost::math::constants::pi<double>() - dif; else if (dif < -boost::math::constants::pi<double>()) dif += 2.0*boost::math::constants::pi<double>(); // we include a sign change to have dif > 0 } else dif = current_joint_position - joint_position_; // check bounds bool result = dif <= (joint_tolerance_above_+2*std::numeric_limits<double>::epsilon()) && dif >= (-joint_tolerance_below_-2*std::numeric_limits<double>::epsilon()); if (verbose) logInform("Constraint %s:: Joint name: '%s', actual value: %f, desired value: %f, tolerance_above: %f, tolerance_below: %f", result ? "satisfied" : "violated", joint_variable_name_.c_str(), current_joint_position, joint_position_, joint_tolerance_above_, joint_tolerance_below_); return ConstraintEvaluationResult(result, constraint_weight_ * fabs(dif)); }
static bool ini_parseKey(Ini* ini, char* line) { int i = 0; char key[256]; char value[1024]; int strLen = str_len(line); bool keyFound = false; Section* section; key[0] = '\0'; value[0] = '\0'; for (i = 0; i < strLen; i++) { if (keyFound) { str_ncpy(value, (line + i), strLen - i); value[strLen - i] = '\0'; break; } if ((line[i] == '=') && keyFound == false) { keyFound = true; str_ncpy(key, line, i); key[i] = '\0'; continue; } } str_trim(key); str_trim(value); if (str_len(key) == 0) { logWarn("No key in line '%s'", line); return false; } if (str_len(value) == 0) { logWarn("No value in line '%s'", line); return false; } if (ini->sections->size == 0) { logWarn("There is no section to add the key"); return false; } // Get the last section added section = (Section*)list_get(ini->sections, (ini->sections->size - 1)); return ini_addKey(ini, section, key, value); }
/** * Read file, returning contents in buf * * @return file size on success, -1 on error */ static int readFile(const char *filename, char **buf) { int fd, res; struct stat statBuf; logVerb("%s('%s')\n", __func__, filename); if ((fd = open(filename, O_RDONLY, S_IRUSR | S_IWUSR)) < 0) { if (errno == ENOENT) logWarn("File '%s' not found\n", filename); return fd; } if ((res = stat(filename, &statBuf)) < 0) { logSysError("%s.stat\n", __func__); return res; } *buf = malloc(statBuf.st_size + 1); if (read(fd, *buf, statBuf.st_size) < 0) dieSysError("read()\n"); close(fd); return statBuf.st_size; }
void Master::onStart() { CliArguments &args = CliArguments::getInstance(); #ifdef WIN32 m_settings = new Settings("mbedsys.org", "NodeBus", QSettings::NativeFormat); #else m_settings = new Settings(args.getValue("config").toString(), QSettings::NativeFormat); #endif m_settings->define("master/pidfile", tr("Path of the file where the service PID will be written in"), NODEBUS_DEFAULT_PIDFILE); m_settings->define("master/bundle-rootpath", tr("Bundle root directory path"), NODEBUS_DEFAULT_PLUGIN_DIR_PATH); m_settings->define("master/registry-service-name", tr("Registry service name"), NODEBUS_DEFAULT_REGISTRY_SERVICE_NAME); if (args.isEnabled("edit-settings")) { m_settings->setup(); throw ExitApplicationException(); } QString path = m_settings->value("master/bundle-rootpath").toString(); QDirIterator it(path, QStringList("*.so"), QDir::Files, QDirIterator::Subdirectories); logFiner() << "Search for bundles in the directory " << path; while (it.hasNext()) { QString file = it.next(); logFinest() << "Found file " << file; try { BundlePtr bundle = new Bundle(file); m_bundles[bundle->property("Bundle-SymbolicName").toString()] = bundle; logFine() << "Found bundle " << bundle->property("Bundle-Name") << " (" << bundle->property("Bundle-SymbolicName") << ')'; } catch (Exception &e) { logWarn() << "Invalid bundle file " << file << " (" << e.message() << ')'; } } if (m_bundles.isEmpty()) { throw ApplicationException("No valid bundle found in the directory " + path); } }
Matrix4f Node::getGlobalTransform(bool with_scale) const { Matrix4f ret; Matrix4f self_mat; if(with_scale) { const Transformf* trans = static_cast<const Transformf*>(this); self_mat = Matrix4f(*trans); } else { self_mat = Matrix4f(rotation,position); } if(parent() != 0) { if(parent()->type() == ParentOfNode::NODE) { const Node* parentNode = static_cast<const Node*>(parent()); ret = parentNode->getGlobalTransform(with_scale) * self_mat; } else { ret = self_mat; } } else { logWarn("trying to access globalTransform on unlinked node"); } return ret; }
int main(int argc, char *argv[]) { /* dbgmsg() ** You can use '|dbgmsg()| exactly as if it was '|printf()| the difference ** is that the output will go on the file defined with '|utlSetOuput()| ** (or '|stderr| if no file has been specified) */ dbgmsg("This message will go on stderr %d\n",1); utlSetOutput("utlh1.dbg"); dbgmsg("This message is on utlh1.log"); utlSetOutput("utlh2.dbg"); /* the previous file is closed and the new one is opened*/ dbgmsg("This message is on utlh2.log"); utlSetOutput(NULL); dbgmsg("This message will go on stderr %d",2); /* Logging is different from debugging messages in that the logging will ** remain in your production code and you will be able to enable it to ** monitor the application behavior. */ logSetLevel(logALL); logDebug("This is a log debug message. (%d)",logLevel); logSetLevel(logINFO); logDebug("This will not appear"); logMessage("\n%s...continuing",logIndent); logWarn("And now a warning (%d)",5); logSetFile("utlh1.log","w"); logError("An error!"); logFatal("An unrecoverable error"); return (0); }
void StbImageFactory::load(ResourceData *resource) { StbImage* stbresource = static_cast<StbImage*>(resource); int x,y,comp; stbi_uc* data = stbi_load(stbresource->path().toLocal8Bit().data(), &x, &y, &comp, stbresource->m_comp); if(data != 0) { logInfo( "StbImage loaded " << resource->name() << " (" << x << "x" << y << ")"); stbresource->m_data = data; stbresource->m_width = x; stbresource->m_height = y; // If we asked 0 components comp now contains the number of components if(stbresource->m_comp == 0) stbresource->m_comp = comp; stbresource->m_state = StbImage::STATE_LOADED; stbresource->buildTexture(); } else { logWarn( "StbImage failed to load " << resource->name() << "\n" << stbi_failure_reason()); } }
bool operator()(const ConstraintSamplerPtr &a, const ConstraintSamplerPtr &b) const { const std::vector<std::string> &alinks = a->getJointModelGroup()->getUpdatedLinkModelNames(); const std::vector<std::string> &blinks = b->getJointModelGroup()->getUpdatedLinkModelNames(); std::set<std::string> a_updates(alinks.begin(), alinks.end()); std::set<std::string> b_updates(blinks.begin(), blinks.end()); bool a_contains_b = std::includes(a_updates.begin(), a_updates.end(), b_updates.begin(), b_updates.end()); bool b_contains_a = std::includes(b_updates.begin(), b_updates.end(), a_updates.begin(), a_updates.end()); //a contains b and sets are not equal if (a_contains_b && !b_contains_a) return true; if (b_contains_a && !a_contains_b) return false; //sets are equal or disjoint bool a_depends_on_b = false; bool b_depends_on_a = false; const std::vector<std::string> &fda = a->getFrameDependency(); const std::vector<std::string> &fdb = b->getFrameDependency(); for (std::size_t i = 0 ; i < fda.size() && !a_depends_on_b ; ++i) for (std::size_t j = 0 ; j < blinks.size() ; ++j) if (blinks[j] == fda[i]) { a_depends_on_b = true; break; } for (std::size_t i = 0 ; i < fdb.size() && !b_depends_on_a ; ++i) for (std::size_t j = 0 ; j < alinks.size() ; ++j) if (alinks[j] == fdb[i]) { b_depends_on_a = true; break; } if (b_depends_on_a && a_depends_on_b) { logWarn("Circular frame dependency! Sampling will likely produce invalid results (sampling for groups '%s' and '%s')", a->getJointModelGroup()->getName().c_str(), b->getJointModelGroup()->getName().c_str()); return true; } if (b_depends_on_a && !a_depends_on_b) return true; if(a_depends_on_b && !b_depends_on_a) return false; // prefer sampling JointConstraints first JointConstraintSampler *ja = dynamic_cast<JointConstraintSampler*>(a.get()); JointConstraintSampler *jb = dynamic_cast<JointConstraintSampler*>(b.get()); if (ja && jb == NULL) return true; if (jb && ja == NULL) return false; // neither depends on either, so break ties based on group name return (a->getJointModelGroup()->getName() < b->getJointModelGroup()->getName()); }
/** * Expands the heap space by {KERNEL_HEAP_EXPAND_STEP} bytes. * * @return whether the operation was successful */ bool KernelHeap::expandHeap() { // check limit if (heapEnd > CONST_KERNEL_HEAP_MAXIMUM_END) { logDebug("%! maximum reached during expansion", "kernheap"); return false; } // Expand virtual space for (VirtualAddress virt = heapEnd; virt < heapEnd + KERNEL_HEAP_EXPAND_STEP; virt = virt + PAGE_SIZE) { // get a new physical page PhysicalAddress page = PPallocator::allocate(); if (!page) { logWarn("%! no pages left for expanding", "kernheap"); return false; } // map the page AddressSpace::map(virt, page, DEFAULT_KERNEL_TABLE_FLAGS, DEFAULT_KERNEL_PAGE_FLAGS); } // Create header allocator.expand(KERNEL_HEAP_EXPAND_STEP); heapEnd = heapEnd + KERNEL_HEAP_EXPAND_STEP; logDebug("%! expanded to end %h (%ikb in use)", "kernheap", heapEnd, usedMemoryAmount / 1024); return true; }
bool robot_model::FloatingJointModel::normalizeRotation(std::vector<double> &values) const { // normalize the quaternion if we need to double normSqr = values[3] * values[3] + values[4] * values[4] + values[5] * values[5] + values[6] * values[6]; if (fabs(normSqr - 1.0) > std::numeric_limits<double>::epsilon() * 100.0) { double norm = sqrt(normSqr); if (norm < std::numeric_limits<double>::epsilon() * 100.0) { logWarn("Quaternion is zero in RobotState *representation. Setting to identity"); values[3] = 0.0; values[4] = 0.0; values[5] = 0.0; values[6] = 1.0; } else { values[3] /= norm; values[4] /= norm; values[5] /= norm; values[6] /= norm; } return true; } else return false; }
/** * Read the CRT protocol header returning the length of the data field */ static int readHeader(int sd, void *buf) { char *p = (char *) buf; int len; if ((len = recvBytes(sd, buf, CERT_HEADER_LEN)) <= 0) return len; if (p[0] != 'C' || p[1] != 'R' || p[2] != 'T') { logError("Bad MAGIC received in header\n"); return -2; } if (p[3] != '0') { logError("Unknown protocol/request received in header\n"); return -2; } certHeader_t *req = (certHeader_t *) buf; req->length = htonl(req->length); if (req->length == 0) { logWarn("Received header with data length = %d\n", req->length); return 0; } return req->length; }
size_t sampleSourcePcmWrite(SampleSourcePcmData self, const SampleBuffer sampleBuffer) { size_t pcmSamplesWritten = 0; size_t numSamplesToWrite = (size_t)(sampleBuffer->numChannels * sampleBuffer->blocksize); if(self == NULL || self->fileHandle == NULL) { logCritical("Corrupt PCM data structure"); return false; } if(self->dataBufferNumItems < (size_t)(sampleBuffer->numChannels * sampleBuffer->blocksize)) { self->dataBufferNumItems = (size_t)(sampleBuffer->numChannels * sampleBuffer->blocksize); self->interlacedPcmDataBuffer = (short*)realloc(self->interlacedPcmDataBuffer, sizeof(short) * self->dataBufferNumItems); } // Clear the PCM data buffer just to be safe memset(self->interlacedPcmDataBuffer, 0, sizeof(short) * self->dataBufferNumItems); sampleBufferGetPcmSamples(sampleBuffer, self->interlacedPcmDataBuffer, self->isLittleEndian != isHostLittleEndian()); pcmSamplesWritten = fwrite(self->interlacedPcmDataBuffer, sizeof(short), numSamplesToWrite, self->fileHandle); if(pcmSamplesWritten < numSamplesToWrite) { logWarn("Short write to PCM file"); return pcmSamplesWritten; } logDebug("Wrote %d samples to PCM file", pcmSamplesWritten); return pcmSamplesWritten; }
void RenderThread::render(RenderRequest* req) { logFiner(QString("RenderThread::render : req 0x%1").arg((long)req,0,16)); if (req->type() == RenderRequest::Preview) { preview_request = req; // rendering a preview preempts everything except files and previews if (isRendering()) switch (current_request->type()) { case RenderRequest::Image: case RenderRequest::Queued: stopRendering(); default: ; } } else if (req->type() == RenderRequest::Image) image_request = req; else if (request_queue.contains(req)) logWarn(QString("RenderThread::render : req 0x%1 already queued") .arg((long)req,0,16)); else { logFine("RenderThread::render : queueing req %#x", (long)req); req->setFinished(false); rqueue_mutex.lock(); request_queue.enqueue(req); rqueue_mutex.unlock(); } }
void LMS1xx::login() { char buf[100]; int result; sprintf(buf, "%c%s%c", 0x02, "sMN SetAccessMode 03 F4724744", 0x03); fd_set readset; struct timeval timeout; do //loop until data is available to read { timeout.tv_sec = 1; timeout.tv_usec = 0; write(socket_fd_, buf, strlen(buf)); FD_ZERO(&readset); FD_SET(socket_fd_, &readset); result = select(socket_fd_ + 1, &readset, NULL, NULL, &timeout); } while (result <= 0); int len = read(socket_fd_, buf, 100); if (buf[0] != 0x02) logWarn("invalid packet recieved"); buf[len] = 0; logDebug("RX: %s", buf); }
void LoggerBase::logWarnPrintf(const char* fname, const char* funcName, int lineNum, const char* msg, ...) { va_list args; va_start(args, msg); char buff[256] = { 0 }; vsnprintf(buff, sizeof(buff)-1, msg, args); logWarn(buff, fname, funcName, lineNum); va_end(args); }
bool kinematic_constraints::OrientationConstraint::configure(const moveit_msgs::OrientationConstraint &oc) { //clearing out any old data clear(); link_model_ = kmodel_->getLinkModel(oc.link_name); if(!link_model_) { logWarn("Could not find link model for link name %s", oc.link_name.c_str()); return false; } Eigen::Quaterniond q; tf::quaternionMsgToEigen(oc.orientation, q); if (fabs(q.norm() - 1.0) > 1e-3) { logWarn("Orientation constraint for link '%s' is probably incorrect: %f, %f, %f, %f. Assuming identity instead.", oc.link_name.c_str(), oc.orientation.x, oc.orientation.y, oc.orientation.z, oc.orientation.w); q = Eigen::Quaterniond(1.0, 0.0, 0.0, 0.0); } if (oc.header.frame_id.empty()) logWarn("No frame specified for position constraint on link '%s'!", oc.link_name.c_str()); if (tf_->isFixedFrame(oc.header.frame_id)) { tf_->transformQuaternion(oc.header.frame_id, q, q); desired_rotation_frame_id_ = tf_->getTargetFrame(); desired_rotation_matrix_ = Eigen::Matrix3d(q); desired_rotation_matrix_inv_ = desired_rotation_matrix_.inverse(); mobile_frame_ = false; } else { desired_rotation_frame_id_ = oc.header.frame_id; desired_rotation_matrix_ = Eigen::Matrix3d(q); mobile_frame_ = true; } std::stringstream matrix_str; matrix_str << desired_rotation_matrix_; logDebug("The desired rotation matrix for link '%s' in frame %s is:\n%s", oc.link_name.c_str(), desired_rotation_frame_id_.c_str(), matrix_str.str().c_str()); if (oc.weight <= std::numeric_limits<double>::epsilon()) { logWarn("The weight on position constraint for link '%s' is near zero. Setting to 1.0.", oc.link_name.c_str()); constraint_weight_ = 1.0; } else constraint_weight_ = oc.weight; absolute_x_axis_tolerance_ = fabs(oc.absolute_x_axis_tolerance); if (absolute_x_axis_tolerance_ < std::numeric_limits<double>::epsilon()) logWarn("Near-zero value for absolute_x_axis_tolerance"); absolute_y_axis_tolerance_ = fabs(oc.absolute_y_axis_tolerance); if (absolute_y_axis_tolerance_ < std::numeric_limits<double>::epsilon()) logWarn("Near-zero value for absolute_y_axis_tolerance"); absolute_z_axis_tolerance_ = fabs(oc.absolute_z_axis_tolerance); if (absolute_z_axis_tolerance_ < std::numeric_limits<double>::epsilon()) logWarn("Near-zero value for absolute_z_axis_tolerance"); return link_model_ != NULL; }
bool LedReader::doReads() { int i, len; quint32 values; char val[16]; int fd; values = 0; for (i = 0; i < NUM_LEDS; i++) { fd = open(qPrintable(m_ledSysPathBrightness.at(i)), O_RDONLY); if (fd < 0) { logWarn(QString("Error opening %1 : %2") .arg(m_ledSysPathBrightness.at(i)) .arg(strerror(errno))); break; } memset(val, 0, sizeof(val)); len = read(fd, val, 8); if (len < 1) { logWarn(QString("read error[%1]: len = %2 %3") .arg(i).arg(len) .arg(strerror(errno))); close(fd); break; } close(fd); if (val[0] == '1') values |= (1 << i); } if (i < NUM_LEDS) return false; emit newData(values); return true; }
bool user_switch(const char* user, const char* pass) { char shell[256]; char homedir[256]; char uidString[256] = {0}; long handle; gid_t gid; uid_t uid; if (user == NULL) { logError("Unable to start a pam session with a null user"); return false; } handle = pam_auth("su", user, pass); if (handle == 0) { logWarn("Authentication failed for user '%s'", user); return false; } if (!pam_startSession(handle)) { logWarn("Failed to start a session with the user '%s'", user); return false; } if (! pam_setEnv(handle)) { logWarn("Failed to customize user environment for the user '%s'", user); return false; } if (! user_getINFO(user, &gid, &uid, shell, homedir)) { logError("Unable to get user information"); return false; } str_sprintf(uidString, "%d", uid); setenv("SHELL", shell, 1); setenv("PATH", "/bin:/usr/bin:/usr/X11R6/bin:/usr/local/bin", 1); setenv("UID", uidString, 1); setenv("USER", user, 1); setenv("HOME", homedir, 1); return (user_setGID(gid) && user_setGroup(user, gid) && fs_setCurrentDir(homedir) && user_setUID(uid)); }
void IntValueEditor::restoreSettings() { if (objectName().isEmpty()) logWarn("IntValueEditor::restoreSettings : nameless object found"); setSingleStep(QSettings().value( QString("intvalueeditor/%1/singlestep").arg(objectName()), singleStep()).toInt()); default_step = singleStep(); }
void CFSClient::appClientReceiveE2E(int servicePort, SYNTRO_EHEAD *message, int length) { if (servicePort != m_CFSPort) { logWarn(QString("Message received with incorrect service port %1").arg(servicePort)); free(message); return; } m_CFSThread->postThreadMessage(SYNTRO_CFS_MESSAGE, length, message); }
void ompl_interface::ModelBasedStateSpace::setTagSnapToSegment(double snap) { if (snap < 0.0 || snap > 1.0) logWarn("Snap to segment for tags is a ratio. It's value must be between 0.0 and 1.0. Value remains as previously set (%lf)", tag_snap_to_segment_); else { tag_snap_to_segment_ = snap; tag_snap_to_segment_complement_ = 1.0 - tag_snap_to_segment_; } }
static int _canHostDo(const char* pluginName, const char* canDoString) { boolByte supported = false; logDebug("Plugin '%s' asked if we can do '%s'", pluginName, canDoString); if(!strcmp(canDoString, EMPTY_STRING)) { logWarn("Plugin '%s' asked if we can do an empty string. This is probably a bug.", pluginName); } else if(!strcmp(canDoString, "sendVstEvents")) { supported = true; } else if(!strcmp(canDoString, "sendVstMidiEvent")) { supported = true; } else if(!strcmp(canDoString, "sendVstTimeInfo")) { supported = true; } else if(!strcmp(canDoString, "receiveVstEvents")) { supported = false; } else if(!strcmp(canDoString, "receiveVstMidiEvent")) { supported = false; } else if(!strcmp(canDoString, "reportConnectionChanges")) { supported = false; } else if(!strcmp(canDoString, "acceptIOChanges")) { supported = false; } else if(!strcmp(canDoString, "sizeWindow")) { supported = false; } else if(!strcmp(canDoString, "offline")) { supported = false; } else if(!strcmp(canDoString, "openFileSelector")) { supported = false; } else if(!strcmp(canDoString, "closeFileSelector")) { supported = false; } else if(!strcmp(canDoString, "startStopProcess")) { supported = true; } else if(!strcmp(canDoString, "shellCategory")) { supported = true; } else if(!strcmp(canDoString, "sendVstMidiEventFlagIsRealtime")) { supported = false; } else { logInfo("Plugin '%s' asked if host canDo '%s' (unimplemented)", pluginName, canDoString); } return supported; }
rviz::BoolProperty* moveit_rviz_plugin::PerLinkObjBase::getBoolProperty( const std::string& name) { rviz::BoolProperty *p = NULL; std::map<std::string, rviz::Property*>::iterator it = extra_property_map_.find(name); if (it != extra_property_map_.end()) p = dynamic_cast<rviz::BoolProperty*>(it->second); if (!p) logWarn("No bool property '%s' found",name.c_str()); return p; }
// Factory : ElementContainer* ElementContainer::create(Type type) { switch(type) { case ARRAY: return new ArrayElementContainer(); default: logWarn("element container type \"", getTypeStr(type), "\" not implemented, will probably crash !"); return NULL; } }
static void _remapFileToErrorReport(ErrorReporter errorReporter, ProgramOption option, boolByte copyFile) { if(option->enabled) { if(copyFile) { // TODO: Slight abuse of private field, probably should avoid doing that... if(!errorReportCopyFileToReport(errorReporter, option->_data.string)) { logWarn("Failed copying '%s' to error report directory, please include this file manually", option->_data.string->data); } } errorReporterRemapPath(errorReporter, option->_data.string); } }