void Loader::cancelRequests(DocLoader* dl) { DeprecatedPtrListIterator<Request> pIt(m_requestsPending); while (pIt.current()) { if (pIt.current()->docLoader() == dl) { cache()->remove(pIt.current()->cachedResource()); m_requestsPending.remove(pIt); dl->decrementRequestCount(); } else ++pIt; } Vector<SubresourceLoader*, 256> loadersToCancel; RequestMap::iterator end = m_requestsLoading.end(); for (RequestMap::iterator i = m_requestsLoading.begin(); i != end; ++i) { Request* r = i->second; if (r->docLoader() == dl) loadersToCancel.append(i->first.get()); } for (unsigned i = 0; i < loadersToCancel.size(); ++i) { SubresourceLoader* loader = loadersToCancel[i]; didFail(loader, true); } if (dl->loadInProgress()) ASSERT(dl->requestCount() == 1); else ASSERT(dl->requestCount() == 0); }
void SQLProcedure::Fetch() { if (!m_bHasFetched) { XMLProcedureCall proc; proc.SetDataSource( m_pBroker ); proc.AddProcedure("describe-results", m_strQuery ); proc.AddAttribute("DescribeProcedure", "yes"); // If specific params have been specified use them. // Otherwise the statement will be bound to spaces for // intermediate execution to determine the result set. GStringIterator pIt(&m_strParamList); while(pIt()) { const char *pzName = pIt++; const char *pzValue = pIt++; proc.AddParameter(pzName, pzValue); } if (m_strDBDriver.Length()) proc.AddAttribute("Driver", m_strDBDriver ); if (m_strDBServer.Length()) proc.AddAttribute("Server", m_strDBServer ); if (m_strSchema.Length()) proc.AddAttribute("Schema", m_strSchema ); if (m_strDBUser.Length()) proc.AddAttribute("DBUser", m_strDBUser ); if (m_strDBPass.Length()) proc.AddAttribute("DBPassword", m_strDBPass ); proc.Execute(this, true); m_bHasFetched = true; } }
//------------------------------------------------------------------------ void CServerGameTokenSynch::FullSynch(int channelId, bool reset) { if(reset) ResetChannel(channelId); IGameTokenItPtr pIt(m_pGTS->GetGameTokenIterator()); while(IGameToken *pGameToken=pIt->Next()) { if((pGameToken->GetFlags()&EGAME_TOKEN_MODIFIED) && ((pGameToken->GetFlags()&EGAME_TOKEN_LOCALONLY)==0)) AddToQueueFor(channelId, pGameToken->GetName()); } }
void CXRayObjectExport::buildEdgeTable( MDagPath& mesh ) { //. if ( !smoothing ) return; // Create our edge lookup table and initialize all entries to NULL // MFnMesh fnMesh( mesh ); edgeTableSize = fnMesh.numVertices(); edgeTable = xr_alloc<SXREdgeInfoPtr>(edgeTableSize); ZeroMemory(edgeTable,edgeTableSize*sizeof(int)); // Add entries, for each edge, to the lookup table // MItMeshEdge eIt( mesh ); for ( ; !eIt.isDone(); eIt.next() ) { bool smooth = eIt.isSmooth(); addEdgeInfo( eIt.index(0), eIt.index(1), smooth ); } // Fill in referenced polygons // MItMeshPolygon pIt( mesh ); for ( ; !pIt.isDone(); pIt.next() ) { int pvc = pIt.polygonVertexCount(); for ( int v=0; v<pvc; v++ ) { int a = pIt.vertexIndex( v ); int b = pIt.vertexIndex( v==(pvc-1) ? 0 : v+1 ); SXREdgeInfoPtr elem = findEdgeInfo( a, b ); if ( NULL != elem ) { int edgeId = pIt.index(); if ( INVALID_ID == elem->polyIds[0] ) { elem->polyIds[0] = edgeId; } else { elem->polyIds[1] = edgeId; } } } } CreateSmoothingGroups( fnMesh ); }
SpecificWorker::State SpecificWorker::plan() { //Check if the point is accesible from robot position // QVec qposR = inner->transform("laser",qpos,"world"); // if ( checkFreeWay( qposR )) // { // qDebug() << __FUNCTION__ << "Free way found. Leaving for VERIFY_POINT"; // return State::VERIFY_POINT; // } // //set the robot's current position in robotNode map->set(robotNode, inner->transform("world","robot")); //search closes node to roobot float dist = std::numeric_limits< float >::max(), d; for (lemon::ListGraph::NodeIt n(graph); n != lemon::INVALID; ++n) { d = (qpos - map->operator[](n)).norm2(); if( d < dist ) { dist = d; closestNode = n; } } qDebug() << __FUNCTION__ << "dist to new point" << d << "at node with position:" << map->operator[](closestNode); //Search shortest path along graph from closest node to robot if( closestNode != robotNode) { float dd; bool reached = dijkstra(graph,*edgeMap).path(path).dist(dd).run(robotNode,closestNode); qDebug() << reached << d; for( lemon::PathNodeIt<lemon::Path<lemon::ListGraph> > pIt(graph, path); pIt != lemon::INVALID; ++pIt) qDebug() << map->operator[](pIt); qDebug() << "---------------"; } return State::GOTO_POINTS; }
void ItemSerializer::toJson(std::ostream& out, const sserialize::Static::Array< sserialize::Static::spatial::GeoPolygon >& polys) const { out << "["; if (polys.size()) { sserialize::Static::spatial::GeoMultiPolygon::PolygonList::const_iterator pIt(polys.cbegin()), pEnd(polys.cend()); sserialize::Static::spatial::GeoMultiPolygon::PolygonList::const_reference gp(*pIt); out << "["; toJson(out, gp.cbegin(), gp.cend()); out << "]"; for(++pIt; pIt != pEnd; ++pIt) { out << ",["; gp = *pIt; toJson(out, gp.cbegin(), gp.cend()); out << "]"; } } out << "]"; }
errlHndl_t configureHbrtHypIds(const bool i_configForPhyp) { TRACDCOMP( g_trac_runtime, ENTER_MRK "configureHbrtHypIds" ); errlHndl_t pError = NULL; TARGETING::PredicateCTM isaProc( TARGETING::CLASS_CHIP, TARGETING::TYPE_PROC); TARGETING::PredicateCTM isaMembuf( TARGETING::CLASS_CHIP, TARGETING::TYPE_MEMBUF); TARGETING::PredicateCTM isaCore( TARGETING::CLASS_UNIT, TARGETING::TYPE_CORE); TARGETING::PredicatePostfixExpr isaProcMembufOrCore; isaProcMembufOrCore.push(&isaProc).push(&isaMembuf).Or() .push(&isaCore).Or(); TARGETING::TargetRangeFilter pIt( TARGETING::targetService().begin(), TARGETING::targetService().end(), &isaProcMembufOrCore); for (; pIt; ++pIt) { auto hbrtHypId = HBRT_HYP_ID_UNKNOWN; // Phyp is the only special case if(i_configForPhyp) { auto rtType = RT_TYPE_UNKNOWN; pError = getRtTypeForTarget(*pIt,rtType); if(pError) { break; } if( (*pIt)->getAttr<TARGETING::ATTR_TYPE>() == TARGETING::TYPE_CORE) { if(TARGETING::is_fused_mode()) { // If we're in fused core mode, all core ID's must // match that of the parent EX auto type = TARGETING::TYPE_EX; const TARGETING::Target* pEx = TARGETING::getParent(*pIt,type); // If this fails, everything is already hosed assert(pEx != NULL); hbrtHypId = (pEx)->getAttr<TARGETING::ATTR_ORDINAL_ID>(); }else { hbrtHypId = (*pIt)->getAttr<TARGETING::ATTR_ORDINAL_ID>(); } } else if( (*pIt)->getAttr<TARGETING::ATTR_TYPE>() == TARGETING::TYPE_MEMBUF ) { //MEMBUF // 0b1000.0000.0000.0000.0000.0PPP.PPPP.MMMM // where PP is the parent proc's id, MMMM is memory channel // TARGETING::TargetHandleList targetList; getParentAffinityTargets(targetList, (*pIt), TARGETING::CLASS_UNIT, TARGETING::TYPE_MCS); assert( !targetList.empty() ); auto mcs_target = targetList[0]; auto pos = mcs_target->getAttr<TARGETING::ATTR_CHIP_UNIT>(); targetList.clear(); getParentAffinityTargets(targetList, mcs_target, TARGETING::CLASS_CHIP, TARGETING::TYPE_PROC); assert( !targetList.empty() ); auto procTarget = targetList[0]; hbrtHypId = procTarget->getAttr<TARGETING::ATTR_ORDINAL_ID>(); hbrtHypId = (hbrtHypId << RT_TARG::MEMBUF_ID_SHIFT); hbrtHypId += pos; } else // just PROC { hbrtHypId = (*pIt)->getAttr<TARGETING::ATTR_ORDINAL_ID>(); } hbrtHypId |= rtType; } else { pError = computeNonPhypRtTarget(*pIt,hbrtHypId); if(pError) { break; } } (*pIt)->setAttr<TARGETING::ATTR_HBRT_HYP_ID>(hbrtHypId); TRACDCOMP( g_trac_runtime, "configureHbrtHypIds> " "Set ATTR_HBRT_HYP_ID attribute to 0x%016llX on targeting target " "with HUID of 0x%08X", hbrtHypId,TARGETING::get_huid(*pIt)); } TRACDCOMP( g_trac_runtime, EXIT_MRK "configureHbrtHypIds" ); return pError; }
//----------------------------------------------------------------------------- // //----------------------------------------------------------------------------- MStatus CVstWeldNode::compute( const MPlug &mPlug, MDataBlock &mDataBlock ) { if ( mPlug == m_oaWeldOutput || mPlug == m_oaTranslate || mPlug == m_oaRotate || mPlug == m_oaTranslateX || mPlug == m_oaTranslateY || mPlug == m_oaTranslateZ || mPlug == m_oaRotateX || mPlug == m_oaRotateY || mPlug == m_oaRotateZ ) { const MObject geoObj = mDataBlock.inputValue( m_iaWorldGeometry ).data(); if ( geoObj.apiType() == MFn::kMeshData ) { MStatus mStatus; MObject meshObj = mDataBlock.inputValue( m_iaWorldGeometry ).asMeshTransformed(); MFnMesh meshFn( meshObj ); MItMeshPolygon pIt( meshObj ); MPointArray facePoints; MArrayDataHandle wiAH = mDataBlock.inputArrayValue( m_iaWeldInput ); MArrayDataHandle woAH = mDataBlock.outputArrayValue( m_oaWeldOutput, &mStatus ); MArrayDataBuilder woADB = woAH.builder( &mStatus ); const int nWeldCount = wiAH.elementCount(); for ( int i = 0; i < nWeldCount; ++i, wiAH.next() ) { MDataHandle wiDH = wiAH.inputValue(); const MMatrix &offsetMatrix = wiDH.child( m_iaOffsetMatrix ).asMatrix(); const MMatrix &inverseParentSpace = wiDH.child( m_iaInverseParentSpace ).asMatrix(); const MEulerRotation::RotationOrder rotationOrder = static_cast< MEulerRotation::RotationOrder >( wiDH.child( m_iaRotateOrder ).asShort() ); MMatrix geoMatrix; switch ( wiDH.child( m_iaType ).asShort() ) { case kMeshFace: { const int nMeshFaceIndex = wiDH.child( m_iaInt ).asInt(); GetMeshMatrix( pIt, nMeshFaceIndex, geoMatrix ); } break; default: merr << "Unknown Weld Type " << wiDH.child( m_iaType ).asShort() << std::endl; break; } const int nWeldIndex = wiAH.elementIndex(); MDataHandle woDH = woADB.addElement( nWeldIndex ); MTransformationMatrix L( inverseParentSpace * offsetMatrix * geoMatrix ); woDH.child( m_oaTranslate ).set( L.getTranslation( MSpace::kWorld ) ); MEulerRotation e = L.rotation().asEulerRotation(); e.reorder( rotationOrder ); woDH.child( m_oaRotate ).set( e.asVector() ); } } else { merr << "Invalid .inputGeometry data of type: " << geoObj.apiTypeStr() << " found while computing " << mPlug.info() << std::endl; return MS::kFailure; } return MS::kSuccess; } return MS::kUnknownParameter; }