static void shape_text(text_line & line, text_itemizer & itemizer, std::map<unsigned,double> & width_map, face_manager_freetype & font_manager, double scale_factor ) { unsigned start = line.first_char(); unsigned end = line.last_char(); size_t length = end - start; if (!length) return; line.reserve(length); std::list<text_item> const& list = itemizer.itemize(start, end); mapnik::value_unicode_string const& text = itemizer.text(); UErrorCode err = U_ZERO_ERROR; mapnik::value_unicode_string shaped; mapnik::value_unicode_string reordered; for (auto const& text_item : list) { face_set_ptr face_set = font_manager.get_face_set(text_item.format_->face_name, text_item.format_->fontset); double size = text_item.format_->text_size * scale_factor; face_set->set_unscaled_character_sizes(); for (auto const& face : *face_set) { UBiDi *bidi = ubidi_openSized(length, 0, &err); ubidi_setPara(bidi, text.getBuffer() + start, length, UBIDI_DEFAULT_LTR, 0, &err); ubidi_writeReordered(bidi, reordered.getBuffer(length), length, UBIDI_DO_MIRRORING, &err); ubidi_close(bidi); reordered.releaseBuffer(length); int32_t num_char = u_shapeArabic(reordered.getBuffer(), length, shaped.getBuffer(length), length, U_SHAPE_LETTERS_SHAPE | U_SHAPE_LENGTH_FIXED_SPACES_NEAR | U_SHAPE_TEXT_DIRECTION_VISUAL_LTR, &err); if (num_char < 0) { MAPNIK_LOG_ERROR(icu_shaper) << " u_shapeArabic returned negative num_char " << num_char; } std::size_t num_chars = static_cast<std::size_t>(num_char); shaped.releaseBuffer(length); bool shaped_status = true; double max_glyph_height = 0; if (U_SUCCESS(err) && (num_chars == length)) { unsigned char_index = 0; U_NAMESPACE_QUALIFIER StringCharacterIterator iter(shaped); for (iter.setToStart(); iter.hasNext();) { UChar ch = iter.nextPostInc(); auto codepoint = FT_Get_Char_Index(face->get_face(), ch); glyph_info g(codepoint,char_index,text_item.format_); //g.offset.clear(); if (g.glyph_index == 0) { shaped_status = false; break; } if (face->glyph_dimensions(g)) { g.face = face; g.scale_multiplier = size / face->get_face()->units_per_EM; double tmp_height = g.height(); if (tmp_height > max_glyph_height) max_glyph_height = tmp_height; width_map[char_index++] += g.advance(); line.add_glyph(std::move(g), scale_factor); } } } if (!shaped_status) continue; line.update_max_char_height(max_glyph_height); return; } } }
/** * @param aDamagedRegion this region, relative to aWidgetView, is invalidated in * every widget child of aWidgetView, plus aWidgetView's own widget */ void nsViewManager::InvalidateWidgetArea(nsView *aWidgetView, const nsRegion &aDamagedRegion) { NS_ASSERTION(aWidgetView->GetViewManager() == this, "InvalidateWidgetArea called on view we don't own"); nsIWidget* widget = aWidgetView->GetWidget(); #if 0 nsRect dbgBounds = aDamagedRegion.GetBounds(); printf("InvalidateWidgetArea view:%X (%d) widget:%X region: %d, %d, %d, %d\n", aWidgetView, aWidgetView->IsAttachedToTopLevel(), widget, dbgBounds.x, dbgBounds.y, dbgBounds.width, dbgBounds.height); #endif // If the widget is hidden, it don't cover nothing if (widget && !widget->IsVisible()) { return; } if (!widget) { // The root view or a scrolling view might not have a widget // (for example, during printing). We get here when we scroll // during printing to show selected options in a listbox, for example. return; } // Update all child widgets with the damage. In the process, // accumulate the union of all the child widget areas, or at least // some subset of that. nsRegion children; if (widget->GetTransparencyMode() != eTransparencyTransparent) { for (nsIWidget* childWidget = widget->GetFirstChild(); childWidget; childWidget = childWidget->GetNextSibling()) { nsView* view = nsView::GetViewFor(childWidget); NS_ASSERTION(view != aWidgetView, "will recur infinitely"); nsWindowType type; childWidget->GetWindowType(type); if (view && childWidget->IsVisible() && type != eWindowType_popup) { NS_ASSERTION(type == eWindowType_plugin, "Only plugin or popup widgets can be children!"); // We do not need to invalidate in plugin widgets, but we should // exclude them from the invalidation region IF we're not on // Mac. On Mac we need to draw under plugin widgets, because // plugin widgets are basically invisible #ifndef XP_MACOSX // GetBounds should compensate for chrome on a toplevel widget nsIntRect bounds; childWidget->GetBounds(bounds); nsTArray<nsIntRect> clipRects; childWidget->GetWindowClipRegion(&clipRects); for (uint32_t i = 0; i < clipRects.Length(); ++i) { nsRect rr = (clipRects[i] + bounds.TopLeft()). ToAppUnits(AppUnitsPerDevPixel()); children.Or(children, rr - aWidgetView->ViewToWidgetOffset()); children.SimplifyInward(20); } #endif } } } nsRegion leftOver; leftOver.Sub(aDamagedRegion, children); if (!leftOver.IsEmpty()) { const nsRect* r; for (nsRegionRectIterator iter(leftOver); (r = iter.Next());) { nsIntRect bounds = ViewToWidget(aWidgetView, *r); widget->Invalidate(bounds); } } }
extern "C" demuxer_t* demux_open_rtp(demuxer_t* demuxer) { Boolean success = False; do { TaskScheduler* scheduler = BasicTaskScheduler::createNew(); if (scheduler == NULL) break; UsageEnvironment* env = BasicUsageEnvironment::createNew(*scheduler); if (env == NULL) break; RTSPClient* rtspClient = NULL; SIPClient* sipClient = NULL; if (demuxer == NULL || demuxer->stream == NULL) break; // shouldn't happen demuxer->stream->eof = 0; // just in case // Look at the stream's 'priv' field to see if we were initiated // via a SDP description: char* sdpDescription = (char*)(demuxer->stream->priv); if (sdpDescription == NULL) { // We weren't given a SDP description directly, so assume that // we were given a RTSP or SIP URL: char const* protocol = demuxer->stream->streaming_ctrl->url->protocol; char const* url = demuxer->stream->streaming_ctrl->url->url; if (strcmp(protocol, "rtsp") == 0) { if (rtsp_transport_http == 1) { rtsp_transport_http = demuxer->stream->streaming_ctrl->url->port; rtsp_transport_tcp = 1; } rtspClient = RTSPClient::createNew(*env, verbose, "MPlayer", rtsp_transport_http); if (rtspClient == NULL) { fprintf(stderr, "Failed to create RTSP client: %s\n", env->getResultMsg()); break; } sdpDescription = openURL_rtsp(rtspClient, url); } else { // SIP unsigned char desiredAudioType = 0; // PCMU (use 3 for GSM) sipClient = SIPClient::createNew(*env, desiredAudioType, NULL, verbose, "MPlayer"); if (sipClient == NULL) { fprintf(stderr, "Failed to create SIP client: %s\n", env->getResultMsg()); break; } sipClient->setClientStartPortNum(8000); sdpDescription = openURL_sip(sipClient, url); } if (sdpDescription == NULL) { fprintf(stderr, "Failed to get a SDP description from URL \"%s\": %s\n", url, env->getResultMsg()); break; } } // Now that we have a SDP description, create a MediaSession from it: MediaSession* mediaSession = MediaSession::createNew(*env, sdpDescription); if (mediaSession == NULL) break; // Create a 'RTPState' structure containing the state that we just created, // and store it in the demuxer's 'priv' field, for future reference: RTPState* rtpState = new RTPState; rtpState->sdpDescription = sdpDescription; rtpState->rtspClient = rtspClient; rtpState->sipClient = sipClient; rtpState->mediaSession = mediaSession; rtpState->audioBufferQueue = rtpState->videoBufferQueue = NULL; rtpState->flags = 0; rtpState->firstSyncTime.tv_sec = rtpState->firstSyncTime.tv_usec = 0; demuxer->priv = rtpState; int audiofound = 0, videofound = 0; // Create RTP receivers (sources) for each subsession: MediaSubsessionIterator iter(*mediaSession); MediaSubsession* subsession; unsigned desiredReceiveBufferSize; while ((subsession = iter.next()) != NULL) { // Ignore any subsession that's not audio or video: if (strcmp(subsession->mediumName(), "audio") == 0) { if (audiofound) { fprintf(stderr, "Additional subsession \"audio/%s\" skipped\n", subsession->codecName()); continue; } desiredReceiveBufferSize = 100000; } else if (strcmp(subsession->mediumName(), "video") == 0) { if (videofound) { fprintf(stderr, "Additional subsession \"video/%s\" skipped\n", subsession->codecName()); continue; } desiredReceiveBufferSize = 2000000; } else { continue; } if (rtsp_port) subsession->setClientPortNum (rtsp_port); if (!subsession->initiate()) { fprintf(stderr, "Failed to initiate \"%s/%s\" RTP subsession: %s\n", subsession->mediumName(), subsession->codecName(), env->getResultMsg()); } else { fprintf(stderr, "Initiated \"%s/%s\" RTP subsession on port %d\n", subsession->mediumName(), subsession->codecName(), subsession->clientPortNum()); // Set the OS's socket receive buffer sufficiently large to avoid // incoming packets getting dropped between successive reads from this // subsession's demuxer. Depending on the bitrate(s) that you expect, // you may wish to tweak the "desiredReceiveBufferSize" values above. int rtpSocketNum = subsession->rtpSource()->RTPgs()->socketNum(); int receiveBufferSize = increaseReceiveBufferTo(*env, rtpSocketNum, desiredReceiveBufferSize); if (verbose > 0) { fprintf(stderr, "Increased %s socket receive buffer to %d bytes \n", subsession->mediumName(), receiveBufferSize); } if (rtspClient != NULL) { // Issue a RTSP "SETUP" command on the chosen subsession: if (!rtspClient->setupMediaSubsession(*subsession, False, rtsp_transport_tcp)) break; if (!strcmp(subsession->mediumName(), "audio")) audiofound = 1; if (!strcmp(subsession->mediumName(), "video")) videofound = 1; } } } if (rtspClient != NULL) { // Issue a RTSP aggregate "PLAY" command on the whole session: if (!rtspClient->playMediaSession(*mediaSession)) break; } else if (sipClient != NULL) { sipClient->sendACK(); // to start the stream flowing } // Now that the session is ready to be read, do additional // MPlayer codec-specific initialization on each subsession: iter.reset(); while ((subsession = iter.next()) != NULL) { if (subsession->readSource() == NULL) continue; // not reading this unsigned flags = 0; if (strcmp(subsession->mediumName(), "audio") == 0) { rtpState->audioBufferQueue = new ReadBufferQueue(subsession, demuxer, "audio"); rtpState->audioBufferQueue->otherQueue = &(rtpState->videoBufferQueue); rtpCodecInitialize_audio(demuxer, subsession, flags); } else if (strcmp(subsession->mediumName(), "video") == 0) { rtpState->videoBufferQueue = new ReadBufferQueue(subsession, demuxer, "video"); rtpState->videoBufferQueue->otherQueue = &(rtpState->audioBufferQueue); rtpCodecInitialize_video(demuxer, subsession, flags); } rtpState->flags |= flags; } success = True; } while (0); if (!success) return NULL; // an error occurred // Hack: If audio and video are demuxed together on a single RTP stream, // then create a new "demuxer_t" structure to allow the higher-level // code to recognize this: if (demux_is_multiplexed_rtp_stream(demuxer)) { stream_t* s = new_ds_stream(demuxer->video); demuxer_t* od = demux_open(s, DEMUXER_TYPE_UNKNOWN, audio_id, video_id, dvdsub_id, NULL); demuxer = new_demuxers_demuxer(od, od, od); } return demuxer; }
void ESM::NpcStats::save (ESMWriter &esm) const { for (std::map<std::string, Faction>::const_iterator iter (mFactions.begin()); iter!=mFactions.end(); ++iter) { esm.writeHNString ("FACT", iter->first); if (iter->second.mExpelled) { int expelled = 1; esm.writeHNT ("FAEX", expelled); } if (iter->second.mRank >= 0) esm.writeHNT ("FARA", iter->second.mRank); if (iter->second.mReputation) esm.writeHNT ("FARE", iter->second.mReputation); } if (mDisposition) esm.writeHNT ("DISP", mDisposition); for (int i=0; i<27; ++i) { mSkills[i].mRegular.save (esm); mSkills[i].mWerewolf.save (esm); } esm.writeHNT ("HWAT", true); for (int i=0; i<8; ++i) mWerewolfAttributes[i].save (esm); if (mIsWerewolf) esm.writeHNT ("WOLF", mIsWerewolf); if (mBounty) esm.writeHNT ("BOUN", mBounty); if (mReputation) esm.writeHNT ("REPU", mReputation); if (mWerewolfKills) esm.writeHNT ("WKIL", mWerewolfKills); if (mProfit) esm.writeHNT ("PROF", mProfit); if (mLevelProgress) esm.writeHNT ("LPRO", mLevelProgress); esm.writeHNT ("INCR", mSkillIncrease); for (std::vector<std::string>::const_iterator iter (mUsedIds.begin()); iter!=mUsedIds.end(); ++iter) esm.writeHNString ("USED", *iter); if (mTimeToStartDrowning) esm.writeHNT ("DRTI", mTimeToStartDrowning); if (mLastDrowningHit) esm.writeHNT ("DRLH", mLastDrowningHit); if (mLevelHealthBonus) esm.writeHNT ("LVLH", mLevelHealthBonus); if (mCrimeId != -1) esm.writeHNT ("CRID", mCrimeId); }
void dgCollisionSphere::Init (dgFloat32 radius, dgMemoryAllocator* allocator) { m_rtti |= dgCollisionSphere_RTTI; m_radius = radius; m_edgeCount = DG_SPHERE_EDGE_COUNT; m_vertexCount = DG_SPHERE_VERTEX_COUNT; dgCollisionConvex::m_vertex = m_vertex; if (!m_shapeRefCount) { dgInt32 indexList[256]; dgVector tmpVectex[256]; dgVector p0 ( dgFloat32 (1.0f), dgFloat32 (0.0f), dgFloat32 (0.0f), dgFloat32 (0.0f)); dgVector p1 (-dgFloat32 (1.0f), dgFloat32 (0.0f), dgFloat32 (0.0f), dgFloat32 (0.0f)); dgVector p2 ( dgFloat32 (0.0f), dgFloat32 (1.0f), dgFloat32 (0.0f), dgFloat32 (0.0f)); dgVector p3 ( dgFloat32 (0.0f),-dgFloat32 (1.0f), dgFloat32 (0.0f), dgFloat32 (0.0f)); dgVector p4 ( dgFloat32 (0.0f), dgFloat32 (0.0f), dgFloat32 (1.0f), dgFloat32 (0.0f)); dgVector p5 ( dgFloat32 (0.0f), dgFloat32 (0.0f),-dgFloat32 (1.0f), dgFloat32 (0.0f)); dgInt32 i = 1; dgInt32 count = 0; TesselateTriangle (i, p4, p0, p2, count, tmpVectex); TesselateTriangle (i, p4, p2, p1, count, tmpVectex); TesselateTriangle (i, p4, p1, p3, count, tmpVectex); TesselateTriangle (i, p4, p3, p0, count, tmpVectex); TesselateTriangle (i, p5, p2, p0, count, tmpVectex); TesselateTriangle (i, p5, p1, p2, count, tmpVectex); TesselateTriangle (i, p5, p3, p1, count, tmpVectex); TesselateTriangle (i, p5, p0, p3, count, tmpVectex); //dgAssert (count == EDGE_COUNT); dgInt32 vertexCount = dgVertexListToIndexList (&tmpVectex[0].m_x, sizeof (dgVector), 3 * sizeof (dgFloat32), 0, count, indexList, 0.001f); dgAssert (vertexCount == DG_SPHERE_VERTEX_COUNT); for (dgInt32 i = 0; i < vertexCount; i ++) { m_unitSphere[i] = tmpVectex[i]; } dgPolyhedra polyhedra(m_allocator); polyhedra.BeginFace(); for (dgInt32 i = 0; i < count; i += 3) { #ifdef _DEBUG dgEdge* const edge = polyhedra.AddFace (indexList[i], indexList[i + 1], indexList[i + 2]); dgAssert (edge); #else polyhedra.AddFace (indexList[i], indexList[i + 1], indexList[i + 2]); #endif } polyhedra.EndFace(); dgUnsigned64 i1 = 0; dgPolyhedra::Iterator iter (polyhedra); for (iter.Begin(); iter; iter ++) { dgEdge* const edge = &(*iter); edge->m_userData = i1; i1 ++; } for (iter.Begin(); iter; iter ++) { dgEdge* const edge = &(*iter); dgConvexSimplexEdge* const ptr = &m_edgeArray[edge->m_userData]; ptr->m_vertex = edge->m_incidentVertex; ptr->m_next = &m_edgeArray[edge->m_next->m_userData]; ptr->m_prev = &m_edgeArray[edge->m_prev->m_userData]; ptr->m_twin = &m_edgeArray[edge->m_twin->m_userData]; } } for (dgInt32 i = 0; i < DG_SPHERE_VERTEX_COUNT; i ++) { m_vertex[i] = m_unitSphere[i].Scale4 (m_radius); } m_shapeRefCount ++; dgCollisionConvex::m_simplex = m_edgeArray; SetVolumeAndCG (); }
UniValue name_filter (const UniValue& params, bool fHelp) { if (fHelp || params.size () > 5) throw std::runtime_error ( "name_filter (\"regexp\" (\"maxage\" (\"from\" (\"nb\" (\"stat\")))))\n" "\nScan and list names matching a regular expression.\n" "\nArguments:\n" "1. \"regexp\" (string, optional) filter names with this regexp\n" "2. \"maxage\" (numeric, optional, default=36000) only consider names updated in the last \"maxage\" blocks; 0 means all names\n" "3. \"from\" (numeric, optional, default=0) return from this position onward; index starts at 0\n" "4. \"nb\" (numeric, optional, default=0) return only \"nb\" entries; 0 means all\n" "5. \"stat\" (string, optional) if set to the string \"stat\", print statistics instead of returning the names\n" "\nResult:\n" "[\n" + getNameInfoHelp (" ", ",") + " ...\n" "]\n" "\nExamples:\n" + HelpExampleCli ("name_filter", "\"\" 5") + HelpExampleCli ("name_filter", "\"^id/\"") + HelpExampleCli ("name_filter", "\"^id/\" 36000 0 0 \"stat\"") + HelpExampleRpc ("name_scan", "\"^d/\"") ); if (IsInitialBlockDownload ()) throw JSONRPCError(RPC_CLIENT_IN_INITIAL_DOWNLOAD, "Namecoin is downloading blocks..."); /* ********************** */ /* Interpret parameters. */ bool haveRegexp(false); boost::xpressive::sregex regexp; int maxage(36000), from(0), nb(0); bool stats(false); if (params.size () >= 1) { haveRegexp = true; regexp = boost::xpressive::sregex::compile (params[0].get_str ()); } if (params.size () >= 2) maxage = params[1].get_int (); if (maxage < 0) throw JSONRPCError (RPC_INVALID_PARAMETER, "'maxage' should be non-negative"); if (params.size () >= 3) from = params[2].get_int (); if (from < 0) throw JSONRPCError (RPC_INVALID_PARAMETER, "'from' should be non-negative"); if (params.size () >= 4) nb = params[3].get_int (); if (nb < 0) throw JSONRPCError (RPC_INVALID_PARAMETER, "'nb' should be non-negative"); if (params.size () >= 5) { if (params[4].get_str () != "stat") throw JSONRPCError (RPC_INVALID_PARAMETER, "fifth argument must be the literal string 'stat'"); stats = true; } /* ******************************************* */ /* Iterate over names to build up the result. */ UniValue names(UniValue::VARR); unsigned count(0); LOCK (cs_main); valtype name; CNameData data; std::unique_ptr<CNameIterator> iter(pcoinsTip->IterateNames ()); while (iter->next (name, data)) { const int age = chainActive.Height () - data.getHeight (); assert (age >= 0); if (maxage != 0 && age >= maxage) continue; if (haveRegexp) { const std::string nameStr = ValtypeToString (name); boost::xpressive::smatch matches; if (!boost::xpressive::regex_search (nameStr, matches, regexp)) continue; } if (from > 0) { --from; continue; } assert (from == 0); if (stats) ++count; else names.push_back (getNameInfo (name, data)); if (nb > 0) { --nb; if (nb == 0) break; } } /* ********************************************************** */ /* Return the correct result (take stats mode into account). */ if (stats) { UniValue res(UniValue::VOBJ); res.push_back (Pair ("blocks", chainActive.Height ())); res.push_back (Pair ("count", static_cast<int> (count))); return res; } return names; }
void PhysicsSystem::doPhysics(float dt, const std::vector<std::pair<std::string, Ogre::Vector3> >& actors) { //set the DebugRenderingMode. To disable it,set it to 0 //eng->setDebugRenderingMode(1); //set the walkdirection to 0 (no movement) for every actor) for(std::map<std::string,OEngine::Physic::PhysicActor*>::iterator it = mEngine->PhysicActorMap.begin(); it != mEngine->PhysicActorMap.end();it++) { OEngine::Physic::PhysicActor* act = it->second; act->setWalkDirection(btVector3(0,0,0)); } playerMove::playercmd& pm_ref = playerphysics->cmd; pm_ref.rightmove = 0; pm_ref.forwardmove = 0; pm_ref.upmove = 0; //playerphysics->ps.move_type = PM_NOCLIP; for (std::vector<std::pair<std::string, Ogre::Vector3> >::const_iterator iter (actors.begin()); iter!=actors.end(); ++iter) { OEngine::Physic::PhysicActor* act = mEngine->getCharacter(iter->first); //if(iter->first == "player") // std::cout << "This is player\n"; //dirty stuff to get the camera orientation. Must be changed! Ogre::SceneNode *sceneNode = mRender.getScene()->getSceneNode (iter->first); Ogre::Vector3 dir; Ogre::Node* yawNode = sceneNode->getChildIterator().getNext(); Ogre::Node* pitchNode = yawNode->getChildIterator().getNext(); Ogre::Quaternion yawQuat = yawNode->getOrientation(); Ogre::Quaternion pitchQuat = pitchNode->getOrientation(); // unused //Ogre::Quaternion both = yawQuat * pitchQuat; playerphysics->ps.viewangles.x = pitchQuat.getPitch().valueDegrees(); playerphysics->ps.viewangles.z = 0; playerphysics->ps.viewangles.y = yawQuat.getYaw().valueDegrees() *-1 + 90; if(mFreeFly) { Ogre::Vector3 dir1(iter->second.x,iter->second.z,-iter->second.y); pm_ref.rightmove = -dir1.x; pm_ref.forwardmove = dir1.z; pm_ref.upmove = dir1.y; //std::cout << "Current angle" << yawQuat.getYaw().valueDegrees() - 90<< "\n"; //playerphysics->ps.viewangles.x = pitchQuat.getPitch().valueDegrees(); //std::cout << "Pitch: " << yawQuat.getPitch() << "Yaw:" << yawQuat.getYaw() << "Roll: " << yawQuat.getRoll() << "\n"; dir = 0.07*(yawQuat*pitchQuat*dir1); } else { Ogre::Quaternion quat = yawNode->getOrientation(); Ogre::Vector3 dir1(iter->second.x,iter->second.z,-iter->second.y); pm_ref.rightmove = -dir1.x; pm_ref.forwardmove = dir1.z; pm_ref.upmove = dir1.y; dir = 0.025*(quat*dir1); } //set the walk direction act->setWalkDirection(btVector3(dir.x,-dir.z,dir.y)); } mEngine->stepSimulation(dt); }
static bool get_segments(const SkPath& path, const SkMatrix& m, SegmentArray* segments, SkPoint* fanPt, int* vCount, int* iCount, SkRect* devBounds) { SkPath::Iter iter(path, true); // This renderer over-emphasizes very thin path regions. We use the distance // to the path from the sample to compute coverage. Every pixel intersected // by the path will be hit and the maximum distance is sqrt(2)/2. We don't // notice that the sample may be close to a very thin area of the path and // thus should be very light. This is particularly egregious for degenerate // line paths. We detect paths that are very close to a line (zero area) and // draw nothing. DegenerateTestData degenerateData; SkPath::Direction dir; // get_direction can fail for some degenerate paths. if (!get_direction(path, m, &dir)) { return false; } for (;;) { SkPoint pts[4]; SkPath::Verb verb = iter.next(pts); switch (verb) { case SkPath::kMove_Verb: m.mapPoints(pts, 1); update_degenerate_test(°enerateData, pts[0]); devBounds->set(pts->fX, pts->fY, pts->fX, pts->fY); break; case SkPath::kLine_Verb: { m.mapPoints(&pts[1], 1); update_degenerate_test(°enerateData, pts[1]); add_line_to_segment(pts[1], segments, devBounds); break; } case SkPath::kQuad_Verb: m.mapPoints(pts, 3); update_degenerate_test(°enerateData, pts[1]); update_degenerate_test(°enerateData, pts[2]); add_quad_segment(pts, segments, devBounds); break; case SkPath::kCubic_Verb: { m.mapPoints(pts, 4); update_degenerate_test(°enerateData, pts[1]); update_degenerate_test(°enerateData, pts[2]); update_degenerate_test(°enerateData, pts[3]); add_cubic_segments(pts, dir, segments, devBounds); break; }; case SkPath::kDone_Verb: if (degenerateData.isDegenerate()) { return false; } else { compute_vectors(segments, fanPt, dir, vCount, iCount); return true; } default: break; } } }
// Execute the command MStatus OgreExporter::doIt(const MArgList& args) { // clean up delete m_pMesh; delete m_pMaterialSet; // Parse the arguments. m_params.parseArgs(args); // Create output files m_params.openFiles(); // Create a new empty mesh m_pMesh = new Mesh(); // Create a new empty material set m_pMaterialSet = new MaterialSet(); // Save current time for later restore m_curTime = MAnimControl::currentTime(); // Save active selection list for later restore MGlobal::getActiveSelectionList(m_selList); /**************************** LOAD DATA **********************************/ if (m_params.exportAll) { // We are exporting the whole scene std::cout << "Export the whole scene\n"; std::cout.flush(); MItDag dagIter; MFnDagNode worldDag (dagIter.root()); MDagPath worldPath; worldDag.getPath(worldPath); stat = translateNode(worldPath); } else { // We are translating a selection std::cout << "Export selected objects\n"; std::cout.flush(); // Get the selection list MSelectionList activeList; stat = MGlobal::getActiveSelectionList(activeList); if (MS::kSuccess != stat) { std::cout << "Error retrieving selection list\n"; std::cout.flush(); exit(); return MS::kFailure; } MItSelectionList iter(activeList); for ( ; !iter.isDone(); iter.next()) { MDagPath dagPath; stat = iter.getDagPath(dagPath); stat = translateNode(dagPath); } } // Load vertex animations if (m_params.exportVertAnims) m_pMesh->loadAnims(m_params); // Load blend shapes if (m_params.exportBlendShapes) m_pMesh->loadBlendShapes(m_params); // Restore skeleton to correct pose if (m_pMesh->getSkeleton()) m_pMesh->getSkeleton()->restorePose(); // Load skeleton animation (do it now, so we have loaded all needed joints) if (m_pMesh->getSkeleton() && m_params.exportSkelAnims) { // Load skeleton animations m_pMesh->getSkeleton()->loadAnims(m_params); } /**************************** WRITE DATA **********************************/ stat = writeOgreData(); std::cout << "Export completed succesfully\n"; std::cout.flush(); exit(); return MS::kSuccess; }
MStatus motionTrace::redoIt() // // Description // This method performs the action of the command. // // This method iterates over all selected items and // prints out connected plug and dependency node type // information. // { MStatus stat; // Status code MObjectArray picked; MObject dependNode; // Selected dependency node // Create a selection list iterator // MSelectionList slist; MGlobal::getActiveSelectionList( slist ); MItSelectionList iter( slist, MFn::kInvalid,&stat ); // Iterate over all selected dependency nodes // and save them in a list // for ( ; !iter.isDone(); iter.next() ) { // Get the selected dependency node // if ( MS::kSuccess != iter.getDependNode( dependNode ) ) { cerr << "Error getting the dependency node" << endl; continue; } picked.append( dependNode ); } // array of arrays for object position MPointArray *pointArrays = new MPointArray [ picked.length() ]; unsigned int i; double time; // Sample the animation using start, end, by values for ( time = start; time <= end; time+=by ) { MTime timeval(time); MGlobal::viewFrame( timeval ); // Iterate over selected dependency nodes // for ( i = 0; i < picked.length(); i++ ) { // Get the selected dependency node // dependNode = picked[i]; // Create a function set for the dependency node // MFnDependencyNode fnDependNode( dependNode ); // Get the translation attribute values MObject txAttr; txAttr = fnDependNode.attribute( MString("translateX"), &stat ); MPlug txPlug( dependNode, txAttr ); double tx; stat = txPlug.getValue( tx ); MObject tyAttr; tyAttr = fnDependNode.attribute( MString("translateY"), &stat ); MPlug tyPlug( dependNode, tyAttr ); double ty; stat = tyPlug.getValue( ty ); MObject tzAttr; tzAttr = fnDependNode.attribute( MString("translateZ"), &stat ); MPlug tzPlug( dependNode, tzAttr ); double tz; stat = tzPlug.getValue( tz ); #if 0 fprintf( stderr, "Time = %2.2lf, XYZ = ( %2.2lf, %2.2lf, %2.2lf )\n\n", time, tx, ty, tz ); #endif pointArrays[i].append( MPoint( tx, ty, tz )) ; } } // make a path curve for each selected object for ( i = 0; i < picked.length(); i++ ) jMakeCurve( pointArrays[i] ); delete [] pointArrays; return MS::kSuccess; }
Boolean DarwinInjector ::setDestination(char const* remoteRTSPServerNameOrAddress, char const* remoteFileName, char const* sessionName, char const* sessionInfo, portNumBits remoteRTSPServerPortNumber, char const* remoteUserName, char const* remotePassword, char const* sessionAuthor, char const* sessionCopyright, int timeout) { char* sdp = NULL; char* url = NULL; Boolean success = False; // until we learn otherwise do { // Construct a RTSP URL for the remote stream: char const* const urlFmt = "rtsp://%s:%u/%s"; unsigned urlLen = strlen(urlFmt) + strlen(remoteRTSPServerNameOrAddress) + 5 /* max short len */ + strlen(remoteFileName); url = new char[urlLen]; sprintf(url, urlFmt, remoteRTSPServerNameOrAddress, remoteRTSPServerPortNumber, remoteFileName); // Begin by creating our RTSP client object: fRTSPClient = new RTSPClientForDarwinInjector(envir(), url, fVerbosityLevel, fApplicationName, this); if (fRTSPClient == NULL) break; // Get the remote RTSP server's IP address: struct in_addr addr; { NetAddressList addresses(remoteRTSPServerNameOrAddress); if (addresses.numAddresses() == 0) break; NetAddress const* address = addresses.firstAddress(); addr.s_addr = *(unsigned*)(address->data()); } AddressString remoteRTSPServerAddressStr(addr); // Construct a SDP description for the session that we'll be streaming: char const* const sdpFmt = "v=0\r\n" "o=- %u %u IN IP4 127.0.0.1\r\n" "s=%s\r\n" "i=%s\r\n" "c=IN IP4 %s\r\n" "t=0 0\r\n" "a=x-qt-text-nam:%s\r\n" "a=x-qt-text-inf:%s\r\n" "a=x-qt-text-cmt:source application:%s\r\n" "a=x-qt-text-aut:%s\r\n" "a=x-qt-text-cpy:%s\r\n"; // plus, %s for each substream SDP unsigned sdpLen = strlen(sdpFmt) + 20 /* max int len */ + 20 /* max int len */ + strlen(sessionName) + strlen(sessionInfo) + strlen(remoteRTSPServerAddressStr.val()) + strlen(sessionName) + strlen(sessionInfo) + strlen(fApplicationName) + strlen(sessionAuthor) + strlen(sessionCopyright) + fSubstreamSDPSizes; unsigned const sdpSessionId = our_random32(); unsigned const sdpVersion = sdpSessionId; sdp = new char[sdpLen]; sprintf(sdp, sdpFmt, sdpSessionId, sdpVersion, // o= line sessionName, // s= line sessionInfo, // i= line remoteRTSPServerAddressStr.val(), // c= line sessionName, // a=x-qt-text-nam: line sessionInfo, // a=x-qt-text-inf: line fApplicationName, // a=x-qt-text-cmt: line sessionAuthor, // a=x-qt-text-aut: line sessionCopyright // a=x-qt-text-cpy: line ); char* p = &sdp[strlen(sdp)]; SubstreamDescriptor* ss; for (ss = fHeadSubstream; ss != NULL; ss = ss->next()) { sprintf(p, "%s", ss->sdpLines()); p += strlen(p); } // Do a RTSP "ANNOUNCE" with this SDP description: Authenticator auth; Authenticator* authToUse = NULL; if (remoteUserName[0] != '\0' || remotePassword[0] != '\0') { auth.setUsernameAndPassword(remoteUserName, remotePassword); authToUse = &auth; } fWatchVariable = 0; (void)fRTSPClient->sendAnnounceCommand(sdp, genericResponseHandler, authToUse); // Now block (but handling events) until we get a response: envir().taskScheduler().doEventLoop(&fWatchVariable); delete[] fResultString; if (fResultCode != 0) break; // an error occurred with the RTSP "ANNOUNCE" command // Next, tell the remote server to start receiving the stream from us. // (To do this, we first create a "MediaSession" object from the SDP description.) fSession = MediaSession::createNew(envir(), sdp); if (fSession == NULL) break; ss = fHeadSubstream; MediaSubsessionIterator iter(*fSession); MediaSubsession* subsession; ss = fHeadSubstream; unsigned streamChannelId = 0; while ((subsession = iter.next()) != NULL) { if (!subsession->initiate()) break; fWatchVariable = 0; (void)fRTSPClient->sendSetupCommand(*subsession, genericResponseHandler, True /*streamOutgoing*/, True /*streamUsingTCP*/); // Now block (but handling events) until we get a response: envir().taskScheduler().doEventLoop(&fWatchVariable); delete[] fResultString; if (fResultCode != 0) break; // an error occurred with the RTSP "SETUP" command // Tell this subsession's RTPSink and RTCPInstance to use // the RTSP TCP connection: ss->rtpSink()->setStreamSocket(fRTSPClient->socketNum(), streamChannelId++); if (ss->rtcpInstance() != NULL) { ss->rtcpInstance()->setStreamSocket(fRTSPClient->socketNum(), streamChannelId++); } ss = ss->next(); } if (subsession != NULL) break; // an error occurred above // Tell the RTSP server to start: fWatchVariable = 0; (void)fRTSPClient->sendPlayCommand(*fSession, genericResponseHandler); // Now block (but handling events) until we get a response: envir().taskScheduler().doEventLoop(&fWatchVariable); delete[] fResultString; if (fResultCode != 0) break; // an error occurred with the RTSP "PLAY" command // Finally, make sure that the output TCP buffer is a reasonable size: increaseSendBufferTo(envir(), fRTSPClient->socketNum(), 100*1024); success = True; } while (0); delete[] sdp; delete[] url; return success; }
bool shouldIRInline(const Func* caller, const Func* callee, const Tracelet& tlet) { TraceletIter iter(tlet); return shouldIRInline(caller, callee, iter); }
Array Array::diffImpl(CArrRef array, bool by_key, bool by_value, bool match, PFUNC_CMP key_cmp_function, const void *key_data, PFUNC_CMP value_cmp_function, const void *value_data) const { assert(by_key || by_value); assert(by_key || key_cmp_function == nullptr); assert(by_value || value_cmp_function == nullptr); PFUNC_CMP value_cmp_as_string_function = value_cmp_function; if (!value_cmp_function) { value_cmp_function = SortStringAscending; value_cmp_as_string_function = CompareAsStrings; } Array ret = Array::Create(); if (by_key && !key_cmp_function) { // Fast case for (ArrayIter iter(*this); iter; ++iter) { Variant key(iter.first()); CVarRef value(iter.secondRef()); bool found = false; if (array->exists(key)) { if (by_value) { found = value_cmp_as_string_function( value, array.rvalAt(key, AccessFlags::Key), value_data) == 0; } else { found = true; } } if (found == match) { ret.addLval(key, true).setWithRef(value); } } return ret; } if (!key_cmp_function) { key_cmp_function = SortRegularAscending; } vector<int> perm1; SortData opaque1; int bottom = 0; int top = array.size(); PFUNC_CMP cmp; const void *cmp_data; if (by_key) { cmp = key_cmp_function; cmp_data = key_data; } else { cmp = value_cmp_function; cmp_data = value_data; } SortImpl(perm1, array, opaque1, cmp, by_key, cmp_data); for (ArrayIter iter(*this); iter; ++iter) { Variant target; if (by_key) { target = iter.first(); } else { target = iter.second(); } int mid = -1; int min = bottom; int max = top; while (min < max) { mid = (max + min) / 2; ssize_t pos = opaque1.positions[perm1[mid]]; int cmp_res = cmp(target, by_key ? array->getKey(pos) : array->getValueRef(pos), cmp_data); if (cmp_res > 0) { // outer is bigger min = mid + 1; } else if (cmp_res == 0) { break; } else { max = mid; } } bool found = false; if (min < max) { // found // if checking both, check value if (by_key && by_value) { CVarRef val(iter.secondRef()); // Have to look up and down for matches for (int i = mid; i < max; i++) { ssize_t pos = opaque1.positions[perm1[i]]; if (key_cmp_function(target, array->getKey(pos), key_data) != 0) { break; } if (value_cmp_as_string_function(val, array->getValueRef(pos), value_data) == 0) { found = true; break; } } if (!found) { for (int i = mid-1; i >= min; i--) { ssize_t pos = opaque1.positions[perm1[i]]; if (key_cmp_function(target, array->getKey(pos), key_data) != 0) { break; } if (value_cmp_as_string_function(val, array->getValueRef(pos), value_data) == 0) { found = true; break; } } } } else { // found at mid found = true; } } if (found == match) { ret.addLval(iter.first(), true).setWithRef(iter.secondRef()); } } return ret; }
bool VampEffect::Process() { if (!mPlugin) return false; TrackListOfKindIterator iter(Track::Wave, mTracks); int count = 0; WaveTrack *left = (WaveTrack *)iter.First(); bool multiple = false; int prevTrackChannels = 0; if (GetNumWaveGroups() > 1) { // if there is another track beyond this one and any linked one, // then we're processing more than one track. That means we // should use the originating track name in each new label // track's name, to make clear which is which multiple = true; } while (left) { sampleCount lstart, rstart = 0; sampleCount len; GetSamples(left, &lstart, &len); WaveTrack *right = NULL; int channels = 1; if (left->GetLinked()) { right = (WaveTrack *)iter.Next(); channels = 2; GetSamples(right, &rstart, &len); } size_t step = mPlugin->getPreferredStepSize(); size_t block = mPlugin->getPreferredBlockSize(); bool initialiseRequired = true; if (block == 0) { if (step != 0) block = step; else block = 1024; } if (step == 0) { step = block; } if (prevTrackChannels > 0) { // Plugin has already been initialised, so if the number of // channels remains the same, we only need to do a reset. // Otherwise we need to re-construct the whole plugin, // because a Vamp plugin can't be re-initialised. if (prevTrackChannels == channels) { mPlugin->reset(); initialiseRequired = false; } else { //!!! todo: retain parameters previously set Init(); } } if (initialiseRequired) { if (!mPlugin->initialise(channels, step, block)) { wxMessageBox(_("Sorry, Vamp Plug-in failed to initialize.")); return false; } } LabelTrack *ltrack = mFactory->NewLabelTrack(); if (!multiple) { ltrack->SetName(GetEffectName()); } else { ltrack->SetName(wxString::Format(wxT("%s: %s"), left->GetName().c_str(), GetEffectName().c_str())); } mTracks->Add(ltrack); float **data = new float*[channels]; for (int c = 0; c < channels; ++c) data[c] = new float[block]; sampleCount originalLen = len; sampleCount ls = lstart; sampleCount rs = rstart; while (len) { int request = block; if (request > len) request = len; if (left) left->Get((samplePtr)data[0], floatSample, ls, request); if (right) right->Get((samplePtr)data[1], floatSample, rs, request); if (request < (int)block) { for (int c = 0; c < channels; ++c) { for (int i = request; i < (int)block; ++i) { data[c][i] = 0.f; } } } Vamp::RealTime timestamp = Vamp::RealTime::frame2RealTime (ls, (int)(mRate + 0.5)); Vamp::Plugin::FeatureSet features = mPlugin->process(data, timestamp); AddFeatures(ltrack, features); if (len > (int)step) len -= step; else len = 0; ls += step; rs += step; if (channels > 1) { if (TrackGroupProgress(count, (ls - lstart) / double(originalLen))) return false; } else { if (TrackProgress(count, (ls - lstart) / double(originalLen))) return false; } } Vamp::Plugin::FeatureSet features = mPlugin->getRemainingFeatures(); AddFeatures(ltrack, features); prevTrackChannels = channels; left = (WaveTrack *)iter.Next(); } return true; }
int CLvRtspClient::ThreadOpen( const sqbind::stdString &sUrl, int bVideo, int bAudio, sqbind::CSqMulti *m ) {_STT(); // Lose old container ThreadDestroy(); // Did we get a valid string? if ( !sUrl.length() ) return 0; // Setup usage environment TaskScheduler* scheduler = BasicTaskScheduler::createNew(); if ( !scheduler ) { setLastError( -1, sqbind::oex2std( oexMks( oexT( "BasicTaskScheduler::createNew() failed : " ), m_pEnv->getResultMsg() ) ) ); return 0; } // end if m_pEnv = BasicUsageEnvironment::createNew( *scheduler ); if ( !m_pEnv ) { setLastError( -2, sqbind::oex2std( oexMks( oexT( "BasicUsageEnvironment::createNew() failed : " ), m_pEnv->getResultMsg() ) ) ); return 0; } // end if #if defined( oexDEBUG ) int nVerbosity = 1; #else int nVerbosity = 0; #endif // Create rtsp client m_pRtspClient = RTSPClient::createNew( *m_pEnv, nVerbosity, "CLvRtspClient", m_nTunnelOverHTTPPort ); if ( !m_pRtspClient ) { setLastError( -3, sqbind::oex2std( oexMks( oexT( "RTSPClient::createNew() failed : " ), m_pEnv->getResultMsg() ) ) ); return 0; } // end if char *pOptions = oexNULL; if ( m_bBlindLogin && m && m->isset( oexT( "username" ) ) ) pOptions = m_pRtspClient->sendOptionsCmd( oexStrToMbPtr( sUrl.c_str() ), (char*)oexStrToMbPtr( (*m)[ oexT( "username" ) ].str().c_str() ), (char*)oexStrToMbPtr( (*m)[ oexT( "password" ) ].str().c_str() ) ); else pOptions = m_pRtspClient->sendOptionsCmd( oexStrToMbPtr( sUrl.c_str() ), 0, 0 ); if ( !pOptions ) { setLastError( -4, sqbind::oex2std( oexMks( oexT( "sendOptionsCmd() failed : " ), m_pEnv->getResultMsg() ) ) ); return 0; } // end if // Ditch the options delete [] pOptions; pOptions = oexNULL; char *pSdp = oexNULL; if ( m && m->isset( oexT( "username" ) ) ) pSdp = m_pRtspClient->describeWithPassword( oexStrToMbPtr( sUrl.c_str() ), oexStrToMbPtr( (*m)[ oexT( "username" ) ].str().c_str() ), oexStrToMbPtr( (*m)[ oexT( "password" ) ].str().c_str() ) ); else pSdp = m_pRtspClient->describeURL( oexStrToMbPtr( sUrl.c_str() ) ); if ( !pSdp ) { setLastError( -5, sqbind::oex2std( oexMks( oexT( "describeURL() failed : " ), m_pEnv->getResultMsg() ) ) ); return 0; } // end if // Parse params m_mSdp.parse( oexMbToStrPtr( pSdp ), oexT( "\r\n" ), oexT( ":" ), 1 ); // Create session m_pSession = MediaSession::createNew( *m_pEnv, pSdp ); // Ditch the SDP description delete [] pSdp; pSdp = oexNULL; if ( !m_pSession ) { setLastError( -6, sqbind::oex2std( oexMks( oexT( "MediaSession::createNew() failed : " ), m_pEnv->getResultMsg() ) ) ); return 0; } // end if // Find a video stream MediaSubsessionIterator iter( *m_pSession ); MediaSubsession *pss; int bFoundVideo = 0, bFoundAudio = 0; oex::CStr8 sVTag = "video", sATag = "audio"; while ( 0 != ( pss = iter.next() ) && ( ( bVideo && !bFoundVideo ) || ( bAudio && !bFoundAudio ) ) ) { if ( bVideo && !bFoundVideo && sVTag == pss->mediumName() ) InitVideo( pss ), bFoundVideo = 1; else if ( bAudio && !bFoundAudio && sATag == pss->mediumName() ) InitAudio( pss ), bFoundAudio = 1; } // end while m_bVideo = bFoundVideo; m_bAudio = bFoundAudio; if ( !m_bVideo && !m_bAudio ) { setLastError( -7, sqbind::oex2std( oexMks( oexT( "No Video or audio : " ), m_pEnv->getResultMsg() ) ) ); return 0; } // end if // m_pRtspClient->playMediaSession( *m_pSession, 0, 0, 1.f ); // m_pRtspClient->playMediaSession( *m_pSession, 0, -1.f, 1.f ); return 1; }
void CharIterTest::TestIteration() { UnicodeString text("Now is the time for all good men to come to the aid of their country."); UChar c; int32_t i; { StringCharacterIterator iter(text, 5); UnicodeString iterText; iter.getText(iterText); if (iterText != text) errln("iter.getText() failed"); if (iter.current() != text[(int32_t)5]) errln("Iterator didn't start out in the right place."); c = iter.first(); i = 0; if (iter.startIndex() != 0 || iter.endIndex() != text.length()) errln("startIndex() or endIndex() failed"); logln("Testing forward iteration..."); do { if (c == CharacterIterator::DONE && i != text.length()) errln("Iterator reached end prematurely"); else if (c != text[i]) errln((UnicodeString)"Character mismatch at position " + i + ", iterator has " + UCharToUnicodeString(c) + ", string has " + UCharToUnicodeString(text[i])); if (iter.current() != c) errln("current() isn't working right"); if (iter.getIndex() != i) errln("getIndex() isn't working right"); if (c != CharacterIterator::DONE) { c = iter.next(); i++; } } while (c != CharacterIterator::DONE); c=iter.next(); if(c!= CharacterIterator::DONE) errln("next() didn't return DONE at the end"); c=iter.setIndex(text.length()+1); if(c!= CharacterIterator::DONE) errln("setIndex(len+1) didn't return DONE"); c = iter.last(); i = text.length() - 1; logln("Testing backward iteration..."); do { if (c == CharacterIterator::DONE && i >= 0) errln("Iterator reached end prematurely"); else if (c != text[i]) errln((UnicodeString)"Character mismatch at position " + i + ", iterator has " + UCharToUnicodeString(c) + ", string has " + UCharToUnicodeString(text[i])); if (iter.current() != c) errln("current() isn't working right"); if (iter.getIndex() != i) errln("getIndex() isn't working right"); if(iter.setIndex(i) != c) errln("setIndex() isn't working right"); if (c != CharacterIterator::DONE) { c = iter.previous(); i--; } } while (c != CharacterIterator::DONE); c=iter.previous(); if(c!= CharacterIterator::DONE) errln("previous didn't return DONE at the beginning"); //testing firstPostInc, nextPostInc, setTostart i = 0; c=iter.firstPostInc(); if(c != text[i]) errln((UnicodeString)"firstPostInc failed. Expected->" + UCharToUnicodeString(text[i]) + " Got->" + UCharToUnicodeString(c)); if(iter.getIndex() != i+1) errln((UnicodeString)"getIndex() after firstPostInc() failed"); iter.setToStart(); i=0; if (iter.startIndex() != 0) errln("setToStart failed"); logln("Testing forward iteration..."); do { if (c != CharacterIterator::DONE) c = iter.nextPostInc(); if(c != text[i]) errln((UnicodeString)"Character mismatch at position " + i + (UnicodeString)", iterator has " + UCharToUnicodeString(c) + (UnicodeString)", string has " + UCharToUnicodeString(text[i])); i++; if(iter.getIndex() != i) errln("getIndex() aftr nextPostInc() isn't working right"); if(iter.current() != text[i]) errln("current() after nextPostInc() isn't working right"); } while (iter.hasNext()); c=iter.nextPostInc(); if(c!= CharacterIterator::DONE) errln("nextPostInc() didn't return DONE at the beginning"); } { StringCharacterIterator iter(text, 5, 15, 10); if (iter.startIndex() != 5 || iter.endIndex() != 15) errln("creation of a restricted-range iterator failed"); if (iter.getIndex() != 10 || iter.current() != text[(int32_t)10]) errln("starting the iterator in the middle didn't work"); c = iter.first(); i = 5; logln("Testing forward iteration over a range..."); do { if (c == CharacterIterator::DONE && i != 15) errln("Iterator reached end prematurely"); else if (c != text[i]) errln((UnicodeString)"Character mismatch at position " + i + ", iterator has " + UCharToUnicodeString(c) + ", string has " + UCharToUnicodeString(text[i])); if (iter.current() != c) errln("current() isn't working right"); if (iter.getIndex() != i) errln("getIndex() isn't working right"); if(iter.setIndex(i) != c) errln("setIndex() isn't working right"); if (c != CharacterIterator::DONE) { c = iter.next(); i++; } } while (c != CharacterIterator::DONE); c = iter.last(); i = 14; logln("Testing backward iteration over a range..."); do { if (c == CharacterIterator::DONE && i >= 5) errln("Iterator reached end prematurely"); else if (c != text[i]) errln((UnicodeString)"Character mismatch at position " + i + ", iterator has " + UCharToUnicodeString(c) + ", string has " + UCharToUnicodeString(text[i])); if (iter.current() != c) errln("current() isn't working right"); if (iter.getIndex() != i) errln("getIndex() isn't working right"); if (c != CharacterIterator::DONE) { c = iter.previous(); i--; } } while (c != CharacterIterator::DONE); } }
bool EffectNormalize::Process() { bool wasLinked = false; // set when a track has a linked (stereo) track if (mGain == false && mDC == false) return true; //Iterate over each track this->CopyInputTracks(); // Set up mOutputTracks. bool bGoodResult = true; SelectedTrackListOfKindIterator iter(Track::Wave, mOutputTracks); WaveTrack *track = (WaveTrack *) iter.First(); mCurTrackNum = 0; while (track) { //Get start and end times from track double trackStart = track->GetStartTime(); double trackEnd = track->GetEndTime(); //Set the current bounds to whichever left marker is //greater and whichever right marker is less: mCurT0 = mT0 < trackStart? trackStart: mT0; mCurT1 = mT1 > trackEnd? trackEnd: mT1; // Process only if the right marker is to the right of the left marker if (mCurT1 > mCurT0) { //Transform the marker timepoints to samples sampleCount start = track->TimeToLongSamples(mCurT0); sampleCount end = track->TimeToLongSamples(mCurT1); //Get the track rate and samples mCurRate = track->GetRate(); mCurChannel = track->GetChannel(); if(mStereoInd) // do stereo tracks independently (the easy way) track->GetMinMax(&mMin, &mMax, mCurT0, mCurT1); else { if(!wasLinked) // new mono track or first of a stereo pair { track->GetMinMax(&mMin, &mMax, mCurT0, mCurT1); if(track->GetLinked()) { wasLinked = true; // so we use these values for the next (linked) track track = (WaveTrack *) iter.Next(); // get the next one for the max/min float min, max; track->GetMinMax(&min, &max, mCurT0, mCurT1); mMin = min < mMin ? min : mMin; mMax = max > mMax ? max : mMax; track = (WaveTrack *) iter.Prev(); // back to the one we are on } } else wasLinked = false; // second of the stereo pair, next one is mono or first } //ProcessOne() (implemented below) processes a single track if (!ProcessOne(track, start, end)) { bGoodResult = false; break; } } //Iterate to the next track track = (WaveTrack *) iter.Next(); mCurTrackNum++; } this->ReplaceProcessedTracks(bGoodResult); return bGoodResult; }
//Tests for new API for utf-16 support void CharIterTest::TestIterationUChar32() { UChar textChars[]={ 0x0061, 0x0062, 0xd841, 0xdc02, 0x20ac, 0xd7ff, 0xd842, 0xdc06, 0xd801, 0xdc00, 0x0061, 0x0000}; UnicodeString text(textChars); UChar32 c; int32_t i; { StringCharacterIterator iter(text, 1); UnicodeString iterText; iter.getText(iterText); if (iterText != text) errln("iter.getText() failed"); if (iter.current32() != text[(int32_t)1]) errln("Iterator didn't start out in the right place."); c=iter.setToStart(); i=0; i=iter.move32(1, CharacterIterator::kStart); c=iter.current32(); if(c != text.char32At(1) || i!=1) errln("move32(1, kStart) didn't work correctly expected %X got %X", c, text.char32At(1) ); i=iter.move32(2, CharacterIterator::kCurrent); c=iter.current32(); if(c != text.char32At(4) || i!=4) errln("move32(2, kCurrent) didn't work correctly expected %X got %X i=%ld", c, text.char32At(4), i); i=iter.move32(-2, CharacterIterator::kCurrent); c=iter.current32(); if(c != text.char32At(1) || i!=1) errln("move32(-2, kCurrent) didn't work correctly expected %X got %X i=%d", c, text.char32At(1), i); i=iter.move32(-2, CharacterIterator::kEnd); c=iter.current32(); if(c != text.char32At((text.length()-3)) || i!=(text.length()-3)) errln("move32(-2, kEnd) didn't work correctly expected %X got %X i=%d", c, text.char32At((text.length()-3)), i); c = iter.first32(); i = 0; if (iter.startIndex() != 0 || iter.endIndex() != text.length()) errln("startIndex() or endIndex() failed"); logln("Testing forward iteration..."); do { /* logln("c=%d i=%d char32At=%d", c, i, text.char32At(i)); */ if (c == CharacterIterator::DONE && i != text.length()) errln("Iterator reached end prematurely"); else if(iter.hasNext() == FALSE && i != text.length()) errln("Iterator reached end prematurely. Failed at hasNext"); else if (c != text.char32At(i)) errln("Character mismatch at position %d, iterator has %X, string has %X", i, c, text.char32At(i)); if (iter.current32() != c) errln("current32() isn't working right"); if(iter.setIndex32(i) != c) errln("setIndex32() isn't working right"); if (c != CharacterIterator::DONE) { c = iter.next32(); i=UTF16_NEED_MULTIPLE_UCHAR(c) ? i+2 : i+1; } } while (c != CharacterIterator::DONE); if(iter.hasNext() == TRUE) errln("hasNext() returned true at the end of the string"); c=iter.setToEnd(); if(iter.getIndex() != text.length() || iter.hasNext() != FALSE) errln("setToEnd failed"); c=iter.next32(); if(c!= CharacterIterator::DONE) errln("next32 didn't return DONE at the end"); c=iter.setIndex32(text.length()+1); if(c!= CharacterIterator::DONE) errln("setIndex32(len+1) didn't return DONE"); c = iter.last32(); i = text.length()-1; logln("Testing backward iteration..."); do { if (c == CharacterIterator::DONE && i >= 0) errln((UnicodeString)"Iterator reached start prematurely for i=" + i); else if(iter.hasPrevious() == FALSE && i>0) errln((UnicodeString)"Iterator reached start prematurely for i=" + i); else if (c != text.char32At(i)) errln("Character mismatch at position %d, iterator has %X, string has %X", i, c, text.char32At(i)); if (iter.current32() != c) errln("current32() isn't working right"); if(iter.setIndex32(i) != c) errln("setIndex32() isn't working right"); if (iter.getIndex() != i) errln("getIndex() isn't working right"); if (c != CharacterIterator::DONE) { c = iter.previous32(); i=UTF16_NEED_MULTIPLE_UCHAR(c) ? i-2 : i-1; } } while (c != CharacterIterator::DONE); if(iter.hasPrevious() == TRUE) errln("hasPrevious returned true after reaching the start"); c=iter.previous32(); if(c!= CharacterIterator::DONE) errln("previous32 didn't return DONE at the beginning"); //testing first32PostInc, next32PostInc, setTostart i = 0; c=iter.first32PostInc(); if(c != text.char32At(i)) errln("first32PostInc failed. Expected->%X Got->%X", text.char32At(i), c); if(iter.getIndex() != UTF16_CHAR_LENGTH(c) + i) errln((UnicodeString)"getIndex() after first32PostInc() failed"); iter.setToStart(); i=0; if (iter.startIndex() != 0) errln("setToStart failed"); logln("Testing forward iteration..."); do { if (c != CharacterIterator::DONE) c = iter.next32PostInc(); if(c != text.char32At(i)) errln("Character mismatch at position %d, iterator has %X, string has %X", i, c, text.char32At(i)); i=UTF16_NEED_MULTIPLE_UCHAR(c) ? i+2 : i+1; if(iter.getIndex() != i) errln("getIndex() aftr next32PostInc() isn't working right"); if(iter.current32() != text.char32At(i)) errln("current() after next32PostInc() isn't working right"); } while (iter.hasNext()); c=iter.next32PostInc(); if(c!= CharacterIterator::DONE) errln("next32PostInc() didn't return DONE at the beginning"); } { StringCharacterIterator iter(text, 1, 11, 10); if (iter.startIndex() != 1 || iter.endIndex() != 11) errln("creation of a restricted-range iterator failed"); if (iter.getIndex() != 10 || iter.current32() != text.char32At(10)) errln("starting the iterator in the middle didn't work"); c = iter.first32(); i = 1; logln("Testing forward iteration over a range..."); do { if (c == CharacterIterator::DONE && i != 11) errln("Iterator reached end prematurely"); else if(iter.hasNext() == FALSE) errln("Iterator reached end prematurely"); else if (c != text.char32At(i)) errln("Character mismatch at position %d, iterator has %X, string has %X", i, c, text.char32At(i)); if (iter.current32() != c) errln("current32() isn't working right"); if(iter.setIndex32(i) != c) errln("setIndex32() isn't working right"); if (c != CharacterIterator::DONE) { c = iter.next32(); i=UTF16_NEED_MULTIPLE_UCHAR(c) ? i+2 : i+1; } } while (c != CharacterIterator::DONE); c=iter.next32(); if(c != CharacterIterator::DONE) errln("error in next32()"); c=iter.last32(); i = 10; logln("Testing backward iteration over a range..."); do { if (c == CharacterIterator::DONE && i >= 5) errln("Iterator reached start prematurely"); else if(iter.hasPrevious() == FALSE && i > 5) errln("Iterator reached start prematurely"); else if (c != text.char32At(i)) errln("Character mismatch at position %d, iterator has %X, string has %X", i, c, text.char32At(i)); if (iter.current32() != c) errln("current32() isn't working right"); if (iter.getIndex() != i) errln("getIndex() isn't working right"); if(iter.setIndex32(i) != c) errln("setIndex32() isn't working right"); if (c != CharacterIterator::DONE) { c = iter.previous32(); i=UTF16_NEED_MULTIPLE_UCHAR(c) ? i-2 : i-1; } } while (c != CharacterIterator::DONE); c=iter.previous32(); if(c!= CharacterIterator::DONE) errln("error on previous32"); } }
Foam::radiation::greyMeanAbsorptionEmission::greyMeanAbsorptionEmission ( const dictionary& dict, const fvMesh& mesh ) : absorptionEmissionModel(dict, mesh), coeffsDict_((dict.subDict(typeName + "Coeffs"))), speciesNames_(0), specieIndex_(0), lookUpTable_ ( fileName(coeffsDict_.lookup("lookUpTableFileName")), mesh.time().constant(), mesh ), thermo_(mesh.lookupObject<basicThermo>("thermophysicalProperties")), EhrrCoeff_(readScalar(coeffsDict_.lookup("EhrrCoeff"))), Yj_(nSpecies_) { label nFunc = 0; const dictionary& functionDicts = dict.subDict(typeName + "Coeffs"); forAllConstIter(dictionary, functionDicts, iter) { // safety: if (!iter().isDict()) { continue; } const word& key = iter().keyword(); speciesNames_.insert(key, nFunc); const dictionary& dict = iter().dict(); coeffs_[nFunc].initialise(dict); nFunc++; } // Check that all the species on the dictionary are present in the // look-up table and save the corresponding indices of the look-up table label j = 0; forAllConstIter(HashTable<label>, speciesNames_, iter) { if (mesh.foundObject<volScalarField>("ft")) { if (lookUpTable_.found(iter.key())) { label index = lookUpTable_.findFieldIndex(iter.key()); Info<< "specie: " << iter.key() << " found on look-up table " << " with index: " << index << endl; specieIndex_[iter()] = index; } else if (mesh.foundObject<volScalarField>(iter.key())) { volScalarField& Y = const_cast<volScalarField&> ( mesh.lookupObject<volScalarField>(iter.key()) ); Yj_.set(j, &Y); specieIndex_[iter()] = 0; j++; Info<< "specie: " << iter.key() << " is being solved" << endl; } else { FatalErrorIn ( "Foam::radiation::greyMeanAbsorptionEmission(const" "dictionary& dict, const fvMesh& mesh)" ) << "specie: " << iter.key() << " is neither in look-up table: " << lookUpTable_.tableName() << " nor is being solved" << nl << exit(FatalError); } } else { FatalErrorIn ( "Foam::radiation::greyMeanAbsorptionEmission(const" "dictionary& dict, const fvMesh& mesh)" ) << "specie ft is not present " << nl << exit(FatalError); } } }
virtual bool run(OperationContext* txn, const string& dbname, BSONObj& cmdObj, int, string& errmsg, BSONObjBuilder& result, bool fromRepl) { if ( cmdObj.firstElement().type() != Array ) { errmsg = "ops has to be an array"; return false; } BSONObj ops = cmdObj.firstElement().Obj(); { // check input BSONObjIterator i( ops ); while ( i.more() ) { BSONElement e = i.next(); if ( e.type() == Object ) continue; errmsg = "op not an object: "; errmsg += e.fieldName(); return false; } } // SERVER-4328 todo : is global ok or does this take a long time? i believe multiple // ns used so locking individually requires more analysis Lock::GlobalWrite globalWriteLock(txn->lockState()); // Preconditions check reads the database state, so needs to be done locked if ( cmdObj["preCondition"].type() == Array ) { BSONObjIterator i( cmdObj["preCondition"].Obj() ); while ( i.more() ) { BSONObj f = i.next().Obj(); BSONObj realres = db.findOne( f["ns"].String() , f["q"].Obj() ); // Apply-ops would never have a $where matcher, so use the default callback, // which will throw an error if $where is found. Matcher m(f["res"].Obj()); if ( ! m.matches( realres ) ) { result.append( "got" , realres ); result.append( "whatFailed" , f ); errmsg = "pre-condition failed"; return false; } } } // apply int num = 0; int errors = 0; BSONObjIterator i( ops ); BSONArrayBuilder ab; const bool alwaysUpsert = cmdObj.hasField("alwaysUpsert") ? cmdObj["alwaysUpsert"].trueValue() : true; while ( i.more() ) { BSONElement e = i.next(); const BSONObj& temp = e.Obj(); string ns = temp["ns"].String(); // Run operations under a nested lock as a hack to prevent them from yielding. // // The list of operations is supposed to be applied atomically; yielding would break // atomicity by allowing an interruption or a shutdown to occur after only some // operations are applied. We are already locked globally at this point, so taking // a DBWrite on the namespace creates a nested lock, and yields are disallowed for // operations that hold a nested lock. Lock::DBWrite lk(txn->lockState(), ns); invariant(Lock::nested()); Client::Context ctx(ns); bool failed = repl::applyOperation_inlock(txn, ctx.db(), temp, false, alwaysUpsert); ab.append(!failed); if ( failed ) errors++; num++; logOpForDbHash(ns.c_str()); } result.append( "applied" , num ); result.append( "results" , ab.arr() ); if ( ! fromRepl ) { // We want this applied atomically on slaves // so we re-wrap without the pre-condition for speed string tempNS = str::stream() << dbname << ".$cmd"; // TODO: possibly use mutable BSON to remove preCondition field // once it is available BSONObjIterator iter(cmdObj); BSONObjBuilder cmdBuilder; while (iter.more()) { BSONElement elem(iter.next()); if (strcmp(elem.fieldName(), "preCondition") != 0) { cmdBuilder.append(elem); } } repl::logOp(txn, "c", tempNS.c_str(), cmdBuilder.done()); } return errors == 0; }
extern "C" DLLEXPORT miBoolean mib_illum_lambert( miColor *result, miState *state, struct mib_illum_lambert *paras) { miColor *ambi, *diff; miTag *light; /* tag of light instance */ int n_l; /* number of light sources */ int i_l; /* offset of light sources */ int m; /* light mode: 0=all, 1=incl, 2=excl */ int samples; /* # of samples taken */ miColor color; /* color from light source */ miColor sum; /* summed sample colors */ miScalar dot_nl; /* dot prod of normal and dir*/ /* check for illegal calls */ if (state->type == miRAY_SHADOW || state->type == miRAY_DISPLACE ) { return(miFALSE); } ambi = mi_eval_color(¶s->ambient); diff = mi_eval_color(¶s->diffuse); m = *mi_eval_integer(¶s->mode); *result = *mi_eval_color(¶s->ambience); /* ambient term */ result->r *= ambi->r; result->g *= ambi->g; result->b *= ambi->b; n_l = *mi_eval_integer(¶s->n_light); i_l = *mi_eval_integer(¶s->i_light); light = mi_eval_tag(paras->light) + i_l; if (m == 1) /* modify light list (inclusive mode) */ mi_inclusive_lightlist(&n_l, &light, state); else if (m == 2) /* modify light list (exclusive mode) */ mi_exclusive_lightlist(&n_l, &light, state); else if (m == 4) { n_l = 0; light = 0; } /* Loop over all light sources */ if (m==4 || n_l) { for (mi::shader::LightIterator iter(state, light, n_l); !iter.at_end(); ++iter) { sum.r = sum.g = sum.b = 0; while (iter->sample()) { dot_nl = iter->get_dot_nl(); iter->get_contribution(&color); sum.r += dot_nl * diff->r * color.r; sum.g += dot_nl * diff->g * color.g; sum.b += dot_nl * diff->b * color.b; } samples = iter->get_number_of_samples(); if (samples) { result->r += sum.r / samples; result->g += sum.g / samples; result->b += sum.b / samples; } } } /* add contribution from indirect illumination (caustics) */ mi_compute_irradiance(&color, state); result->r += color.r * diff->r; result->g += color.g * diff->g; result->b += color.b * diff->b; result->a = 1; return(miTRUE); }
static void LoadHangingBridge (DemoEntityManager* const scene, TriggerManager* const triggerManager, NewtonCollision* const sceneCollision, const char* const name, const dMatrix& location, NewtonBody* const playGroundBody) { NewtonWorld* const world = scene->GetNewton(); DemoEntityManager::dListNode* const bridgeNodes = scene->GetLast(); LoadScene(scene, name, location); // add bridge foundations for (DemoEntityManager::dListNode* node = bridgeNodes->GetNext(); node; node = node->GetNext()) { DemoEntity* const entity = node->GetInfo(); if (entity->GetName().Find("ramp") != -1) { DemoMesh* const mesh = (DemoMesh*)entity->GetMesh(); dAssert (mesh->IsType(DemoMesh::GetRttiType())); NewtonCollision* const collision = NewtonCreateConvexHull(world, mesh->m_vertexCount, mesh->m_vertex, 3 * sizeof (dFloat), 0, 0, NULL); void* const proxy = NewtonSceneCollisionAddSubCollision (sceneCollision, collision); NewtonDestroyCollision (collision); // get the location of this tire relative to the car chassis dMatrix matrix (entity->GetNextMatrix()); NewtonCollision* const bridgeCollision = NewtonSceneCollisionGetCollisionFromNode (sceneCollision, proxy); NewtonSceneCollisionSetSubCollisionMatrix (sceneCollision, proxy, &matrix[0][0]); NewtonCollisionSetUserData(bridgeCollision, entity); } } // add all the planks that form the bridge dTree<NewtonBody*, dString> planks; dFloat plankMass = 30.0f; for (DemoEntityManager::dListNode* node = bridgeNodes->GetNext(); node; node = node->GetNext()) { DemoEntity* const entity = node->GetInfo(); if (entity->GetName().Find("plank") != -1) { DemoMesh* const mesh = (DemoMesh*)entity->GetMesh(); dAssert (mesh->IsType(DemoMesh::GetRttiType())); // note: because the mesh matrix can have scale, for simplicity just apply the local mesh matrix to the vertex cloud dVector pool[128]; const dMatrix& meshMatrix = entity->GetMeshMatrix(); meshMatrix.TransformTriplex(&pool[0].m_x, sizeof (dVector), mesh->m_vertex, 3 * sizeof (dFloat), mesh->m_vertexCount); NewtonCollision* const collision = NewtonCreateConvexHull(world, mesh->m_vertexCount, &pool[0].m_x, sizeof (dVector), 0, 0, NULL); NewtonBody* const body = CreateSimpleBody (world, entity, plankMass, entity->GetNextMatrix(), collision, 0); NewtonDestroyCollision (collision); planks.Insert(body, entity->GetName()); } } // connect each plant with a hinge // calculate the with of a plank dFloat plankwidth = 0.0f; dVector planksideDir (1.0f, 0.0f, 0.0f, 0.0f); { NewtonBody* const body0 = planks.Find("plank01")->GetInfo(); NewtonBody* const body1 = planks.Find("plank02")->GetInfo(); dMatrix matrix0; dMatrix matrix1; NewtonBodyGetMatrix(body0, &matrix0[0][0]); NewtonBodyGetMatrix(body1, &matrix1[0][0]); planksideDir = matrix1.m_posit - matrix0.m_posit; planksideDir = planksideDir.Scale (1.0f / dSqrt (planksideDir % planksideDir)); dVector dir (matrix0.UnrotateVector(planksideDir)); NewtonCollision* const shape = NewtonBodyGetCollision(body0); dVector p0; dVector p1; NewtonCollisionSupportVertex(shape, &dir[0], &p0[0]); dVector dir1 (dir.Scale (-1.0f)); NewtonCollisionSupportVertex(shape, &dir1[0], &p1[0]); plankwidth = dAbs (0.5f * ((p1 - p0) % dir)); } dTree<NewtonBody*, dString>::Iterator iter (planks); iter.Begin(); dMatrix matrix0; NewtonBody* body0 = iter.GetNode()->GetInfo(); NewtonBodyGetMatrix(body0, &matrix0[0][0]); for (iter ++; iter; iter ++) { NewtonBody* const body1 = iter.GetNode()->GetInfo(); dMatrix matrix1; NewtonBodyGetMatrix(body1, &matrix1[0][0]); // calculate the hinge parameter form the matrix location of each plank dMatrix pinMatrix0 (dGetIdentityMatrix()); pinMatrix0[0] = pinMatrix0[1] * planksideDir; pinMatrix0[0] = pinMatrix0[0].Scale (1.0f / dSqrt (pinMatrix0[0] % pinMatrix0[0])); pinMatrix0[2] = pinMatrix0[0] * pinMatrix0[1]; pinMatrix0[0][3] = 0.0f; pinMatrix0[1][3] = 0.0f; pinMatrix0[2][3] = 0.0f; // calculate the pivot pinMatrix0[3] = matrix0.m_posit + pinMatrix0[2].Scale (plankwidth); pinMatrix0[3][3] = 1.0f; dMatrix pinMatrix1 (pinMatrix0); pinMatrix1[3] = matrix1.m_posit - pinMatrix1[2].Scale (plankwidth); pinMatrix1[3][3] = 1.0f; // connect these two plank by a hinge, there a wiggle space between eh hinge that give therefore use the alternate hinge constructor new CustomHinge (pinMatrix0, pinMatrix1, body0, body1); body0 = body1; matrix0 = matrix1; } // connect the last and first plank to the bridge base { iter.Begin(); body0 = iter.GetNode()->GetInfo(); NewtonBodyGetMatrix(body0, &matrix0[0][0]); dMatrix pinMatrix0 (dGetIdentityMatrix()); pinMatrix0[0] = pinMatrix0[1] * planksideDir; pinMatrix0[0] = pinMatrix0[0].Scale (1.0f / dSqrt (pinMatrix0[0] % pinMatrix0[0])); pinMatrix0[2] = pinMatrix0[0] * pinMatrix0[1]; pinMatrix0[0][3] = 0.0f; pinMatrix0[1][3] = 0.0f; pinMatrix0[2][3] = 0.0f; pinMatrix0[3] = matrix0.m_posit - pinMatrix0[2].Scale (plankwidth); new CustomHinge (pinMatrix0, body0, playGroundBody); } { iter.End(); body0 = iter.GetNode()->GetInfo(); NewtonBodyGetMatrix(body0, &matrix0[0][0]); dMatrix pinMatrix0 (dGetIdentityMatrix()); pinMatrix0[0] = pinMatrix0[1] * planksideDir; pinMatrix0[0] = pinMatrix0[0].Scale (1.0f / dSqrt (pinMatrix0[0] % pinMatrix0[0])); pinMatrix0[2] = pinMatrix0[0] * pinMatrix0[1]; pinMatrix0[0][3] = 0.0f; pinMatrix0[1][3] = 0.0f; pinMatrix0[2][3] = 0.0f; pinMatrix0[3] = matrix0.m_posit + pinMatrix0[2].Scale (plankwidth); new CustomHinge (pinMatrix0, body0, playGroundBody); } }
Variant c_Memcache::t_get(CVarRef key, VRefParam flags /*= null*/) { if (key.is(KindOfArray)) { std::vector<const char *> real_keys; std::vector<size_t> key_len; Array keyArr = key.toArray(); real_keys.reserve(keyArr.size()); key_len.reserve(keyArr.size()); for (ArrayIter iter(keyArr); iter; ++iter) { real_keys.push_back(const_cast<char *>(iter.second().toString().c_str())); key_len.push_back(iter.second().toString().length()); } if (!real_keys.empty()) { const char *payload = NULL; size_t payload_len = 0; uint32_t flags = 0; const char *res_key = NULL; size_t res_key_len = 0; memcached_result_st result; memcached_return_t ret = memcached_mget(&m_memcache, &real_keys[0], &key_len[0], real_keys.size()); memcached_result_create(&m_memcache, &result); Array return_val; while ((memcached_fetch_result(&m_memcache, &result, &ret)) != NULL) { if (ret != MEMCACHED_SUCCESS) { // should probably notify about errors continue; } payload = memcached_result_value(&result); payload_len = memcached_result_length(&result); flags = memcached_result_flags(&result); res_key = memcached_result_key_value(&result); res_key_len = memcached_result_key_length(&result); return_val.set(String(res_key, res_key_len, CopyString), memcache_fetch_from_storage(payload, payload_len, flags)); } memcached_result_free(&result); return return_val; } } else { char *payload = NULL; size_t payload_len = 0; uint32_t flags = 0; memcached_return_t ret; String skey = key.toString(); if (skey.length() == 0) { return false; } payload = memcached_get(&m_memcache, skey.c_str(), skey.length(), &payload_len, &flags, &ret); /* This is for historical reasons from libmemcached*/ if (ret == MEMCACHED_END) { ret = MEMCACHED_NOTFOUND; } if (ret == MEMCACHED_NOTFOUND) { return false; } Variant retval = memcache_fetch_from_storage(payload, payload_len, flags); free(payload); return retval; } return false; }
/** * Performs sanity check on the given connection string on whether the seed list * is consistent with the view of the set using replSetGetStatus. */ bool addReplSetShardCheck( const ConnectionString& servers, string* errMsg ) { bool ok = false; BSONObj replSetStat; try { ScopedDbConnection newShardConn(servers.toString()); ok = newShardConn->runCommand( "admin", BSON( "replSetGetStatus" << 1 ), replSetStat ); newShardConn.done(); } catch ( const DBException& ex ) { *errMsg = str::stream() << "Error encountered while checking status of " << servers.toString() << ": " << causedBy( ex ); } if( !ok ) { if ( replSetStat["info"].str() == "configsvr" ) { *errMsg = "the specified mongod is a --configsvr and " "should thus not be a shard server"; } else { *errMsg = str::stream() << "error encountered calling replSetGetStatus: " << replSetStat; } return false; } // if the shard has only one host, make sure it is not part of a replica set string setName = replSetStat["set"].str(); string commandSetName = servers.getSetName(); if ( commandSetName.empty() && ! setName.empty() ) { *errMsg = str::stream() << "host is part of set: " << setName << " use replica set url format <setname>/<server1>,<server2>,...."; return false; } if ( !commandSetName.empty() && setName.empty() ) { *errMsg = str::stream() << "host did not return a set name, " << "is the replica set still initializing?" << replSetStat; return false; } // if the shard is part of replica set, make sure it is the right one if ( ! commandSetName.empty() && ( commandSetName != setName ) ) { *errMsg = str::stream() << "host is part of a different set: " << setName; return false; } // if the shard is part of a replica set, make sure all the hosts mentioned in // 'servers' are part of the set. It is fine if not all members of the set // are present in 'servers'. bool foundAll = true; string offendingHost; if ( ! commandSetName.empty() ) { set<string> hostSet; BSONElement membersElem( replSetStat["members"] ); if ( membersElem.type() == Array ) { BSONArrayIteratorSorted iter( BSONArray( membersElem.Obj() )); while ( iter.more() ) { hostSet.insert( iter.next()["name"].str() ); // host:port } vector<HostAndPort> hosts = servers.getServers(); for ( size_t i = 0 ; i < hosts.size() ; i++ ) { if (!hosts[i].hasPort()) { hosts[i].setPort(CmdLine::DefaultDBPort); } string host = hosts[i].toString(); // host:port if ( hostSet.find( host ) == hostSet.end() ) { offendingHost = host; foundAll = false; break; } } } if ( hostSet.empty() ) { *errMsg = "replSetGetStatus returned an empty set. " " Please wait for the set to initialize and try again."; return false; } } if ( ! foundAll ) { *errMsg = str::stream() << "in seed list " << servers.toString() << ", host " << offendingHost << " does not belong to replica set " << setName; return false; } return true; }
bool Foam::pimpleControl::criteriaSatisfied() { if ((corr_ == 0) || residualControl_.empty() || finalIter()) { return false; } bool firstIter = corr_ == 1; bool achieved = true; const dictionary& solverDict = mesh_.solverPerformanceDict(); forAllConstIter(dictionary, solverDict, iter) { const word& variableName = iter().keyword(); label fieldI = applyToField(variableName); if (fieldI != -1) { const List<lduMatrix::solverPerformance> sp(iter().stream()); const scalar residual = sp.last().initialResidual(); if (firstIter) { residualControl_[fieldI].initialResidual = sp.first().initialResidual(); } bool absCheck = residual < residualControl_[fieldI].absTol; bool relCheck = false; scalar relative = 0.0; if (!firstIter) { scalar iniRes = residualControl_[fieldI].initialResidual + ROOTVSMALL; relative = residual/iniRes; relCheck = relative < residualControl_[fieldI].relTol; } achieved = achieved && (absCheck || relCheck); if (debug) { Info<< algorithmName_ << "loop statistics:" << endl; Info<< " " << variableName << " iter " << corr_ << ": ini res = " << residualControl_[fieldI].initialResidual << ", abs tol = " << residual << " (" << residualControl_[fieldI].absTol << ")" << ", rel tol = " << relative << " (" << residualControl_[fieldI].relTol << ")" << endl; } } } return achieved; }
BonusBlock::BonusBlock(const Reader& lisp) : Block(SpriteManager::current()->create("images/objects/bonus_block/bonusblock.sprite")), contents(), object(0), hit_counter(1), sprite_name(), script(), lightsprite() { Vector pos; contents = CONTENT_COIN; lisp::ListIterator iter(&lisp); while(iter.next()) { const std::string& token = iter.item(); if(token == "x") { iter.value()->get(pos.x); } else if(token == "y") { iter.value()->get(pos.y); } else if(token == "sprite") { iter.value()->get(sprite_name); sprite = SpriteManager::current()->create(sprite_name); } else if(token == "count") { iter.value()->get(hit_counter); } else if(token == "script") { iter.value()->get(script); } else if(token == "contents") { std::string contentstring; iter.value()->get(contentstring); if(contentstring == "coin") { contents = CONTENT_COIN; } else if(contentstring == "firegrow") { contents = CONTENT_FIREGROW; } else if(contentstring == "icegrow") { contents = CONTENT_ICEGROW; } else if(contentstring == "star") { contents = CONTENT_STAR; } else if(contentstring == "1up") { contents = CONTENT_1UP; } else if(contentstring == "custom") { contents = CONTENT_CUSTOM; } else if(contentstring == "script") { // use when bonusblock is to contain ONLY a script contents = CONTENT_SCRIPT; } else if(contentstring == "light") { contents = CONTENT_LIGHT; SoundManager::current()->preload("sounds/switch.ogg"); } else if(contentstring == "trampoline") { contents = CONTENT_TRAMPOLINE; } else if(contentstring == "rain") { contents = CONTENT_RAIN; } else if(contentstring == "explode") { contents = CONTENT_EXPLODE; } else { log_warning << "Invalid box contents '" << contentstring << "'" << std::endl; } } else { if(contents == CONTENT_CUSTOM) { GameObjectPtr game_object = ObjectFactory::instance().create(token, *(iter.lisp())); object = std::dynamic_pointer_cast<MovingObject>(game_object); if(object == 0) throw std::runtime_error( "Only MovingObjects are allowed inside BonusBlocks"); } else { log_warning << "Invalid element '" << token << "' in bonusblock" << std::endl; } } } if(contents == CONTENT_CUSTOM && object == 0) throw std::runtime_error("Need to specify content object for custom block"); if(contents == CONTENT_LIGHT) lightsprite = Surface::create("/images/objects/lightmap_light/bonusblock_light.png"); bbox.set_pos(pos); }
nsresult VorbisTrackEncoder::GetEncodedTrack(EncodedFrameContainer& aData) { if (mEosSetInEncoder) { return NS_OK; } PROFILER_LABEL("VorbisTrackEncoder", "GetEncodedTrack", js::ProfileEntry::Category::OTHER); nsAutoPtr<AudioSegment> sourceSegment; sourceSegment = new AudioSegment(); { // Move all the samples from mRawSegment to sourceSegment. We only hold // the monitor in this block. ReentrantMonitorAutoEnter mon(mReentrantMonitor); // Wait if mEncoder is not initialized, or when not enough raw data, but is // not the end of stream nor is being canceled. while (!mCanceled && mRawSegment.GetDuration() < GetPacketDuration() && !mEndOfStream) { mon.Wait(); } VORBISLOG("GetEncodedTrack passes wait, duration is %lld\n", mRawSegment.GetDuration()); if (mCanceled || mEncodingComplete) { return NS_ERROR_FAILURE; } sourceSegment->AppendFrom(&mRawSegment); } if (mEndOfStream && (sourceSegment->GetDuration() == 0) && !mEosSetInEncoder) { mEncodingComplete = true; mEosSetInEncoder = true; VORBISLOG("[Vorbis] Done encoding."); vorbis_analysis_wrote(&mVorbisDsp, 0); GetEncodedFrames(aData); return NS_OK; } // Start encoding data. AudioSegment::ChunkIterator iter(*sourceSegment); AudioDataValue **vorbisBuffer = vorbis_analysis_buffer(&mVorbisDsp, (int)sourceSegment->GetDuration()); int framesCopied = 0; nsAutoTArray<AudioDataValue, 9600> interleavedPcm; nsAutoTArray<AudioDataValue, 9600> nonInterleavedPcm; interleavedPcm.SetLength(sourceSegment->GetDuration() * mChannels); nonInterleavedPcm.SetLength(sourceSegment->GetDuration() * mChannels); while (!iter.IsEnded()) { AudioChunk chunk = *iter; int frameToCopy = chunk.GetDuration(); if (!chunk.IsNull()) { InterleaveTrackData(chunk, frameToCopy, mChannels, interleavedPcm.Elements() + framesCopied * mChannels); } else { // empty data memset(interleavedPcm.Elements() + framesCopied * mChannels, 0, frameToCopy * mChannels * sizeof(AudioDataValue)); } framesCopied += frameToCopy; iter.Next(); } // De-interleave the interleavedPcm. DeInterleaveTrackData(interleavedPcm.Elements(), framesCopied, mChannels, nonInterleavedPcm.Elements()); // Copy the nonInterleavedPcm to vorbis buffer. for(uint8_t i = 0; i < mChannels; ++i) { memcpy(vorbisBuffer[i], nonInterleavedPcm.Elements() + framesCopied * i, framesCopied * sizeof(AudioDataValue)); } // Now the vorbisBuffer contain the all data in non-interleaved. // Tell the library how much we actually submitted. vorbis_analysis_wrote(&mVorbisDsp, framesCopied); VORBISLOG("vorbis_analysis_wrote framesCopied %d\n", framesCopied); GetEncodedFrames(aData); return NS_OK; }
bool setOption(long option, CVarRef value) { if (m_cp == NULL) { return false; } m_error_no = CURLE_OK; switch (option) { case CURLOPT_INFILESIZE: case CURLOPT_VERBOSE: case CURLOPT_HEADER: case CURLOPT_NOPROGRESS: case CURLOPT_NOBODY: case CURLOPT_FAILONERROR: case CURLOPT_UPLOAD: case CURLOPT_POST: case CURLOPT_FTPLISTONLY: case CURLOPT_FTPAPPEND: case CURLOPT_NETRC: case CURLOPT_PUT: case CURLOPT_TIMEOUT: #if LIBCURL_VERSION_NUM >= 0x071002 case CURLOPT_TIMEOUT_MS: #endif case CURLOPT_FTP_USE_EPSV: case CURLOPT_LOW_SPEED_LIMIT: case CURLOPT_SSLVERSION: case CURLOPT_LOW_SPEED_TIME: case CURLOPT_RESUME_FROM: case CURLOPT_TIMEVALUE: case CURLOPT_TIMECONDITION: case CURLOPT_TRANSFERTEXT: case CURLOPT_HTTPPROXYTUNNEL: case CURLOPT_FILETIME: case CURLOPT_MAXREDIRS: case CURLOPT_MAXCONNECTS: case CURLOPT_CLOSEPOLICY: case CURLOPT_FRESH_CONNECT: case CURLOPT_FORBID_REUSE: case CURLOPT_CONNECTTIMEOUT: #if LIBCURL_VERSION_NUM >= 0x071002 case CURLOPT_CONNECTTIMEOUT_MS: #endif case CURLOPT_SSL_VERIFYHOST: case CURLOPT_SSL_VERIFYPEER: //case CURLOPT_DNS_USE_GLOBAL_CACHE: not thread-safe when set to true case CURLOPT_NOSIGNAL: case CURLOPT_PROXYTYPE: case CURLOPT_BUFFERSIZE: case CURLOPT_HTTPGET: case CURLOPT_HTTP_VERSION: case CURLOPT_CRLF: case CURLOPT_DNS_CACHE_TIMEOUT: case CURLOPT_PROXYPORT: case CURLOPT_FTP_USE_EPRT: case CURLOPT_HTTPAUTH: case CURLOPT_PROXYAUTH: case CURLOPT_FTP_CREATE_MISSING_DIRS: case CURLOPT_FTPSSLAUTH: case CURLOPT_FTP_SSL: case CURLOPT_UNRESTRICTED_AUTH: case CURLOPT_PORT: case CURLOPT_AUTOREFERER: case CURLOPT_COOKIESESSION: case CURLOPT_TCP_NODELAY: case CURLOPT_IPRESOLVE: case CURLOPT_FOLLOWLOCATION: m_error_no = curl_easy_setopt(m_cp, (CURLoption)option, value.toInt64()); break; case CURLOPT_RETURNTRANSFER: m_write.method = value.toBoolean() ? PHP_CURL_RETURN : PHP_CURL_STDOUT; break; case CURLOPT_BINARYTRANSFER: m_write.type = value.toBoolean() ? PHP_CURL_BINARY : PHP_CURL_ASCII; break; case CURLOPT_PRIVATE: case CURLOPT_URL: case CURLOPT_PROXY: case CURLOPT_USERPWD: case CURLOPT_PROXYUSERPWD: case CURLOPT_RANGE: case CURLOPT_CUSTOMREQUEST: case CURLOPT_USERAGENT: case CURLOPT_FTPPORT: case CURLOPT_COOKIE: case CURLOPT_REFERER: case CURLOPT_INTERFACE: case CURLOPT_KRB4LEVEL: case CURLOPT_EGDSOCKET: case CURLOPT_CAINFO: case CURLOPT_CAPATH: case CURLOPT_SSL_CIPHER_LIST: case CURLOPT_SSLKEY: case CURLOPT_SSLKEYTYPE: case CURLOPT_SSLKEYPASSWD: case CURLOPT_SSLENGINE: case CURLOPT_SSLENGINE_DEFAULT: case CURLOPT_SSLCERTTYPE: case CURLOPT_ENCODING: case CURLOPT_COOKIEJAR: case CURLOPT_SSLCERT: case CURLOPT_RANDOM_FILE: case CURLOPT_COOKIEFILE: { String svalue = value.toString(); #if LIBCURL_VERSION_NUM >= 0x071100 /* Strings passed to libcurl as 'char *' arguments, are copied by the library... NOTE: before 7.17.0 strings were not copied. */ m_error_no = curl_easy_setopt(m_cp, (CURLoption)option, svalue.c_str()); #else char *copystr = strndup(svalue.data(), svalue.size()); m_to_free->str.push_back(copystr); m_error_no = curl_easy_setopt(m_cp, (CURLoption)option, copystr); #endif if (option == CURLOPT_URL) m_url = value; } break; case CURLOPT_FILE: case CURLOPT_INFILE: case CURLOPT_WRITEHEADER: case CURLOPT_STDERR: { if (!value.isResource()) { return false; } Resource obj = value.toResource(); if (obj.isNull() || obj.getTyped<File>(true) == NULL) { return false; } switch (option) { case CURLOPT_FILE: m_write.fp = obj; m_write.method = PHP_CURL_FILE; break; case CURLOPT_WRITEHEADER: m_write_header.fp = obj; m_write_header.method = PHP_CURL_FILE; break; case CURLOPT_INFILE: m_read.fp = obj; m_emptyPost = false; break; default: { if (obj.getTyped<PlainFile>(true) == NULL) { return false; } FILE *fp = obj.getTyped<PlainFile>()->getStream(); if (!fp) { return false; } m_error_no = curl_easy_setopt(m_cp, (CURLoption)option, fp); break; } } } break; case CURLOPT_WRITEFUNCTION: m_write.callback = value; m_write.method = PHP_CURL_USER; break; case CURLOPT_READFUNCTION: m_read.callback = value; m_read.method = PHP_CURL_USER; m_emptyPost = false; break; case CURLOPT_HEADERFUNCTION: m_write_header.callback = value; m_write_header.method = PHP_CURL_USER; break; case CURLOPT_POSTFIELDS: m_emptyPost = false; if (value.is(KindOfArray) || value.is(KindOfObject)) { Array arr = value.toArray(); curl_httppost *first = NULL; curl_httppost *last = NULL; for (ArrayIter iter(arr); iter; ++iter) { String key = iter.first().toString(); String val = iter.second().toString(); const char *postval = val.data(); /* The arguments after _NAMELENGTH and _CONTENTSLENGTH * must be explicitly cast to long in curl_formadd * use since curl needs a long not an int. */ if (*postval == '@') { ++postval; m_error_no = (CURLcode)curl_formadd (&first, &last, CURLFORM_COPYNAME, key.data(), CURLFORM_NAMELENGTH, (long)key.size(), CURLFORM_FILE, postval, CURLFORM_END); } else { m_error_no = (CURLcode)curl_formadd (&first, &last, CURLFORM_COPYNAME, key.data(), CURLFORM_NAMELENGTH, (long)key.size(), CURLFORM_COPYCONTENTS, postval, CURLFORM_CONTENTSLENGTH,(long)val.size(), CURLFORM_END); } } if (m_error_no != CURLE_OK) { return false; } m_to_free->post.push_back(first); m_error_no = curl_easy_setopt(m_cp, CURLOPT_HTTPPOST, first); } else { String svalue = value.toString(); #if LIBCURL_VERSION_NUM >= 0x071100 /* with curl 7.17.0 and later, we can use COPYPOSTFIELDS, but we have to provide size before */ m_error_no = curl_easy_setopt(m_cp, CURLOPT_POSTFIELDSIZE, svalue.size()); m_error_no = curl_easy_setopt(m_cp, CURLOPT_COPYPOSTFIELDS, svalue.c_str()); #else char *post = strndup(svalue.data(), svalue.size()); m_to_free->str.push_back(post); m_error_no = curl_easy_setopt(m_cp, CURLOPT_POSTFIELDS, post); m_error_no = curl_easy_setopt(m_cp, CURLOPT_POSTFIELDSIZE, svalue.size()); #endif } break; case CURLOPT_HTTPHEADER: case CURLOPT_QUOTE: case CURLOPT_HTTP200ALIASES: case CURLOPT_POSTQUOTE: if (value.is(KindOfArray) || value.is(KindOfObject)) { Array arr = value.toArray(); curl_slist *slist = NULL; for (ArrayIter iter(arr); iter; ++iter) { String key = iter.first().toString(); String val = iter.second().toString(); slist = curl_slist_append(slist, val.c_str()); if (!slist) { raise_warning("Could not build curl_slist"); return false; } } m_to_free->slist.push_back(slist); m_error_no = curl_easy_setopt(m_cp, (CURLoption)option, slist); } else { raise_warning("You must pass either an object or an array with " "the CURLOPT_HTTPHEADER, CURLOPT_QUOTE, " "CURLOPT_HTTP200ALIASES and CURLOPT_POSTQUOTE " "arguments"); return false; } break; case CURLINFO_HEADER_OUT: if (value.toInt64() == 1) { curl_easy_setopt(m_cp, CURLOPT_DEBUGFUNCTION, curl_debug); curl_easy_setopt(m_cp, CURLOPT_DEBUGDATA, (void *)this); curl_easy_setopt(m_cp, CURLOPT_VERBOSE, 1); } else { curl_easy_setopt(m_cp, CURLOPT_DEBUGFUNCTION, NULL); curl_easy_setopt(m_cp, CURLOPT_DEBUGDATA, NULL); curl_easy_setopt(m_cp, CURLOPT_VERBOSE, 0); } break; case CURLOPT_FB_TLS_VER_MAX: { int64_t val = value.toInt64(); if (value.isInteger() && (val == CURLOPT_FB_TLS_VER_MAX_1_0 || val == CURLOPT_FB_TLS_VER_MAX_1_1 || val == CURLOPT_FB_TLS_VER_MAX_NONE)) { m_opts.set(int64_t(option), value); } else { raise_warning("You must pass CURLOPT_FB_TLS_VER_MAX_1_0, " "CURLOPT_FB_TLS_VER_MAX_1_1 or " "CURLOPT_FB_TLS_VER_MAX_NONE with " "CURLOPT_FB_TLS_VER_MAX"); } } break; case CURLOPT_FB_TLS_CIPHER_SPEC: if (value.isString() && !value.toString().empty()) { m_opts.set(int64_t(option), value); } else { raise_warning("CURLOPT_FB_TLS_CIPHER_SPEC requires a non-empty string"); } break; default: m_error_no = CURLE_FAILED_INIT; throw_invalid_argument("option: %ld", option); break; } m_opts.set(int64_t(option), value); return m_error_no == CURLE_OK; }
// does this cover all cases? bool util::isAnimated(MObject & object, bool checkParent) { MStatus stat; MItDependencyGraph iter(object, MFn::kInvalid, MItDependencyGraph::kUpstream, MItDependencyGraph::kDepthFirst, MItDependencyGraph::kNodeLevel, &stat); if (stat!= MS::kSuccess) { MGlobal::displayError("Unable to create DG iterator "); } // MAnimUtil::isAnimated(node) will search the history of the node // for any animation curve nodes. It will return true for those nodes // that have animation curve in their history. // The average time complexity is O(n^2) where n is the number of history // nodes. But we can improve the best case by split the loop into two. std::vector<MObject> nodesToCheckAnimCurve; for (; !iter.isDone(); iter.next()) { MObject node = iter.thisNode(); if (node.hasFn(MFn::kPluginDependNode) || node.hasFn( MFn::kConstraint ) || node.hasFn(MFn::kPointConstraint) || node.hasFn(MFn::kAimConstraint) || node.hasFn(MFn::kOrientConstraint) || node.hasFn(MFn::kScaleConstraint) || node.hasFn(MFn::kGeometryConstraint) || node.hasFn(MFn::kNormalConstraint) || node.hasFn(MFn::kTangentConstraint) || node.hasFn(MFn::kParentConstraint) || node.hasFn(MFn::kPoleVectorConstraint) || node.hasFn(MFn::kParentConstraint) || node.hasFn(MFn::kTime) || node.hasFn(MFn::kJoint) || node.hasFn(MFn::kGeometryFilt) || node.hasFn(MFn::kTweak) || node.hasFn(MFn::kPolyTweak) || node.hasFn(MFn::kSubdTweak) || node.hasFn(MFn::kCluster) || node.hasFn(MFn::kFluid) || node.hasFn(MFn::kPolyBoolOp)) { return true; } if (node.hasFn(MFn::kExpression)) { MFnExpression fn(node, &stat); if (stat == MS::kSuccess && fn.isAnimated()) { return true; } } // skip shading nodes if (!node.hasFn(MFn::kShadingEngine)) { nodesToCheckAnimCurve.push_back(node); } else { // and don't traverse the rest of their subgraph iter.prune(); } } for (size_t i = 0; i < nodesToCheckAnimCurve.size(); i++) { if (MAnimUtil::isAnimated(nodesToCheckAnimCurve[i], checkParent)) { return true; } } return false; }
Status V1PrivilegeDocumentParser::checkValidPrivilegeDocument(const StringData& dbname, const BSONObj& doc) const { BSONElement userElement = doc[AuthorizationManager::USER_NAME_FIELD_NAME]; BSONElement userSourceElement = doc[AuthorizationManager::USER_SOURCE_FIELD_NAME]; BSONElement passwordElement = doc[AuthorizationManager::PASSWORD_FIELD_NAME]; BSONElement rolesElement = doc[ROLES_FIELD_NAME]; BSONElement otherDBRolesElement = doc[OTHER_DB_ROLES_FIELD_NAME]; BSONElement readOnlyElement = doc[READONLY_FIELD_NAME]; // Validate the "user" element. if (userElement.type() != String) return _badValue("system.users entry needs 'user' field to be a string", 14051); if (makeStringDataFromBSONElement(userElement).empty()) return _badValue("system.users entry needs 'user' field to be non-empty", 14053); // Must set exactly one of "userSource" and "pwd" fields. if (userSourceElement.eoo() == passwordElement.eoo()) { return _badValue("system.users entry must have either a 'pwd' field or a 'userSource' " "field, but not both", 0); } if (!AuthorizationManager::getSupportOldStylePrivilegeDocuments() && rolesElement.eoo()) { return _oldPrivilegeFormatNotSupported(); } // Cannot have both "roles" and "readOnly" elements. if (!rolesElement.eoo() && !readOnlyElement.eoo()) { return _badValue("system.users entry must not have both 'roles' and 'readOnly' fields", 0); } // Validate the "pwd" element, if present. if (!passwordElement.eoo()) { if (passwordElement.type() != String) return _badValue("system.users entry needs 'pwd' field to be a string", 14052); if (makeStringDataFromBSONElement(passwordElement).empty()) return _badValue("system.users entry needs 'pwd' field to be non-empty", 14054); } // Validate the "userSource" element, if present. if (!userSourceElement.eoo()) { if (userSourceElement.type() != String || makeStringDataFromBSONElement(userSourceElement).empty()) { return _badValue("system.users entry needs 'userSource' field to be a non-empty " "string, if present", 0); } if (userSourceElement.str() == dbname) { return _badValue(mongoutils::str::stream() << "'" << dbname << "' is not a valid value for the userSource field in " << dbname << ".system.users entries", 0); } if (rolesElement.eoo()) { return _badValue("system.users entry needs 'roles' field if 'userSource' field " "is present.", 0); } } // Validate the "roles" element. if (!rolesElement.eoo()) { Status status = _checkV1RolesArray(rolesElement); if (!status.isOK()) return status; } if (!otherDBRolesElement.eoo()) { if (dbname != ADMIN_DBNAME) { return _badValue("Only admin.system.users entries may contain 'otherDBRoles' " "fields", 0); } if (rolesElement.eoo()) { return _badValue("system.users entries with 'otherDBRoles' fields must contain " "'roles' fields", 0); } if (otherDBRolesElement.type() != Object) { return _badValue("'otherDBRoles' field must be an object when present in " "system.users entries", 0); } for (BSONObjIterator iter(otherDBRolesElement.embeddedObject()); iter.more(); iter.next()) { Status status = _checkV1RolesArray(*iter); if (!status.isOK()) return status; } } return Status::OK(); }