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