void SyncManagerImpl::AddCreateOpForElementRecurs(RemoteSyncPeer& peer, const ElementPtr& element) { // Construct a CreateOperation for this element XGuid parentGuid = kInvalidXGuid; ElementPtr parent = element->GetParent(); if (parent) { parentGuid = parent->GetGUID(); } { CreateOperationPtr createOp = new CreateOperation( element->GetElementType(), element->GetName(), element->GetGUID(), parentGuid, element->GetXValue(), m_syncContext->GetAuthorityLevel(), m_syncContext); // Add to the list of outgoing ops peer.SendOp(createOp); } // If this is an object element... ObjectElementPtr objElement = ObjectElement::Cast(element); if (objElement) { // Recurs to the children of this element for (int32 i = 0; i < objElement->GetElementCount(); ++i) { AddCreateOpForElementRecurs(peer, objElement->GetElementAt(i)); } } else { // If the element is an array, add Insert operations for all its entries ArrayElement* arrayElement = reflection_cast<ArrayElement>(element); if (arrayElement != nullptr) { int32 numEntries = arrayElement->GetCount(); for (int32 i = 0; i < numEntries; ++i) { InsertOperationPtr insertOp = new InsertOperation( element->GetGUID(), i, arrayElement->GetXValue(i), m_syncContext->GetAuthorityLevel(), m_syncContext); // Add to the list of outgoing ops peer.SendOp(insertOp); } } } }
Handle<Value> ElementJs::setTags(const Arguments& args) { HandleScope scope; ElementPtr e = ObjectWrap::Unwrap<ElementJs>(args.This())->getElement(); if (!e) { return v8::ThrowException(HootExceptionJs::create(IllegalArgumentException( "Unable to set tags on a const Element."))); } Tags& tags = ObjectWrap::Unwrap<TagsJs>(args[0]->ToObject())->getTags(); e->setTags(tags); return scope.Close(Undefined()); }
//--------------------------------------------------------------------- DocumentPtr LockboxContentGetRequest::encode() { DocumentPtr ret = IMessageHelper::createDocumentWithRoot(*this); ElementPtr root = ret->getFirstChildElement(); String clientNonce = IHelper::randomString(32); LockboxInfo lockboxInfo; lockboxInfo.mAccessToken = mLockboxInfo.mAccessToken; if (mLockboxInfo.mAccessSecret.hasData()) { lockboxInfo.mAccessSecretProofExpires = zsLib::now() + Seconds(OPENPEER_STACK_MESSAGE_LOCKBOX_CONTENT_GET_REQUEST_EXPIRES_TIME_IN_SECONDS); lockboxInfo.mAccessSecretProof = IHelper::convertToHex(*IHelper::hmac(*IHelper::hmacKeyFromPassphrase(mLockboxInfo.mAccessSecret), "lockbox-access-validate:" + clientNonce + ":" + IHelper::timeToString(lockboxInfo.mAccessSecretProofExpires) + ":" + lockboxInfo.mAccessToken + ":lockbox-content-get")); } root->adoptAsLastChild(IMessageHelper::createElementWithText("nonce", clientNonce)); if (lockboxInfo.hasData()) { root->adoptAsLastChild(MessageHelper::createElement(lockboxInfo)); } ElementPtr namespacesEl = IMessageHelper::createElement("namespaces"); for (NamespaceInfoMap::iterator iter = mNamespaceInfos.begin(); iter != mNamespaceInfos.end(); ++iter) { const NamespaceInfo &namespaceInfo = (*iter).second; namespacesEl->adoptAsLastChild(MessageHelper::createElement(namespaceInfo)); } if (namespacesEl->hasChildren()) { root->adoptAsLastChild(namespacesEl); } return ret; }
double RieszRep::getNorm(){ if (_repsNotComputed){ cout << "Computing riesz rep dofs" << endl; computeRieszRep(); } vector< ElementPtr > allElems = _mesh->activeElements(); vector< ElementPtr >::iterator elemIt; double normSum = 0.0; for (elemIt=allElems.begin();elemIt!=allElems.end();elemIt++){ ElementPtr elem = *elemIt; int cellID = elem->cellID(); normSum+= _rieszRepNormSquaredGlobal[cellID]; } return sqrt(normSum); }
DOMTokenListImp::DOMTokenListImp(const ElementPtr& element, const std::u16string& localName) : element(element), localName(localName) { if (!element) return; std::u16string value = element->getAttribute(localName); boost::algorithm::split(tokens, value, isSpace); }
void Stage::DestroyElement(ElementPtr inElement) { wxString name = inElement->GetName(); // Make sure this element isn't on our drawing context stack. if (mDrawingContextStack->ContainsElement(inElement)) gLog.Fatal("halyard.element", "%s: Tried to delete element with an active drawing context", inElement->GetLogName()); // Clean up any dangling references to this object. if (inElement == mGrabbedElement) MouseUngrab(mGrabbedElement); if (inElement == mCurrentElement) mCurrentElement = ElementPtr(); if (inElement == mCurrentElementNamedInStatusBar) mCurrentElementNamedInStatusBar = ElementPtr(); MediaElementPtr as_media(inElement, dynamic_cast_tag()); if (as_media && as_media == mWaitElement) EndWait(); // If the element we're deleting is a CursorElement, then we need to // tell it to unregister itself, and then update the cursor we're // displaying in case it has changed. This takes care of // mDesiredCursor and mActualCursor. shared_ptr<CursorElement> as_cursor_elem(inElement, dynamic_cast_tag()); if (as_cursor_elem) { as_cursor_elem->UnregisterWithCursorManager(mCursorManager); Cursor *as_cursor(static_cast<Cursor*>(as_cursor_elem.get())); if (as_cursor == mDesiredCursor) ReplaceDisplayedCursorWithDefault(); ASSERT(as_cursor != mDesiredCursor); ASSERT(as_cursor != mActualCursor); } // We don't have to destroy the object explicity, because the // ElementPtr smart-pointer class will take care of that for us. // // TODO - Implemented delayed destruction so element callbacks can // destroy the element they're attached to. gLog.Trace("halyard.element", "%s: Removed from stage", inElement->GetLogName()); }
void MenuList::fillComboBox() { if (MenuPopup * popup = findChildOfType<MenuPopup>()) { for (size_t idx = 0; idx != popup->getChildCount(); ++idx) { ElementPtr child = popup->el()->children()[idx]; if (MenuItem * item = child->component()->downcast<MenuItem>()) { std::string label = item->getLabel(); WinAPI::ComboBox_Add(handle(), label); } } if (popup->getChildCount() > 0) { WinAPI::ComboBox_SetSelectedIndex(handle(), 0); } } }
//--------------------------------------------------------------------- DocumentPtr SessionDeleteRequest::encode() { DocumentPtr ret = IMessageHelper::createDocumentWithRoot(*this); ElementPtr root = ret->getFirstChildElement(); if (hasAttribute(AttributeType_Locations)) { ElementPtr locationsEl = IMessageHelper::createElement("locations"); root->adoptAsLastChild(locationsEl); for(StringList::const_iterator it = mLocations.begin(); it != mLocations.end(); ++it) { const String &loc = (*it); locationsEl->adoptAsLastChild(IMessageHelper::createElementWithID("location", loc)); } } return ret; }
double RieszRep::computeAlternativeNormSqOnCell(IPPtr ip, ElementPtr elem){ GlobalIndexType cellID = elem->cellID(); Teuchos::RCP<DofOrdering> testOrdering= elem->elementType()->testOrderPtr; bool testVsTest = true; Teuchos::RCP<BasisCache> basisCache = BasisCache::basisCacheForCell(_mesh, cellID, testVsTest,1); int numDofs = testOrdering->totalDofs(); FieldContainer<double> ipMat(1,numDofs,numDofs); ip->computeInnerProductMatrix(ipMat,testOrdering,basisCache); double sum = 0.0; for (int i = 0;i<numDofs;i++){ for (int j = 0;j<numDofs;j++){ sum += _rieszRepDofsGlobal[cellID](i)*_rieszRepDofsGlobal[cellID](j)*ipMat(0,i,j); } } return sum; }
DocumentPtr MultiPartyAPNSPushRequest::encode(message::MultiPartyAPNSPushRequest &msg) { DocumentPtr ret = IMessageHelper::createDocumentWithRoot(msg); ElementPtr root = ret->getFirstChildElement(); if (msg.hasAttribute(message::MultiPartyAPNSPushRequest::AttributeType_UserID)) { root->adoptAsLastChild(IMessageHelper::createElementWithText("userID", msg.mUserID)); } if (msg.hasAttribute(message::MultiPartyAPNSPushRequest::AttributeType_AccessKey)) { root->adoptAsLastChild(IMessageHelper::createElementWithText("accessKey", msg.mAccessKey)); } if (msg.hasAttribute(message::MultiPartyAPNSPushRequest::AttributeType_AccessSecret)) { root->adoptAsLastChild(IMessageHelper::createElementWithText("accessSecret", msg.mAccessSecret)); } if (msg.hasAttribute(message::MultiPartyAPNSPushRequest::AttributeType_LocationID)) { root->adoptAsLastChild(IMessageHelper::createElementWithText("locationID", msg.mLocationID)); } if (msg.hasAttribute(message::MultiPartyAPNSPushRequest::AttributeType_MessageType)) { root->adoptAsLastChild(IMessageHelper::createElementWithText("messageType", msg.mMessageType)); } if (msg.hasAttribute(message::MultiPartyAPNSPushRequest::AttributeType_MessageData)) { root->adoptAsLastChild(IMessageHelper::createElementWithText("messageData", msg.mMessageData)); } if (msg.hasAttribute(message::MultiPartyAPNSPushRequest::AttributeType_UserIDs)) { String usersStr; typedef provisioning::IAccount::UserIDList UserIDList; for (UserIDList::iterator iter = msg.mUserIDs.begin(); iter != msg.mUserIDs.end(); ++iter) { const String &userID = (*iter); if (!userID.isEmpty()) { if (!usersStr.isEmpty()) { usersStr += "," + userID; } else { usersStr += userID; } } } if (!usersStr.isEmpty()) { root->adoptAsLastChild(IMessageHelper::createElementWithText("users", usersStr)); } } return ret; }
ElementPtr OsmApiDbSqlChangesetFileWriter::_getChangeElement(ConstElementPtr element) { ElementPtr changeElement; switch (element->getElementType().getEnum()) { case ElementType::Node: changeElement.reset(new Node(*boost::dynamic_pointer_cast<const Node>(element))); break; case ElementType::Way: changeElement.reset(new Way(*boost::dynamic_pointer_cast<const Way>(element))); break; case ElementType::Relation: changeElement.reset(new Relation(*boost::dynamic_pointer_cast<const Relation>(element))); break; default: throw HootException("Unknown element type"); } return changeElement; }
//----------------------------------------------------------------------- DocumentPtr MessageResult::encode(IPeerFilesPtr peerFile) { DocumentPtr ret = IMessageHelper::createDocumentWithRoot(*this); ElementPtr root = ret->getFirstChildElement(); // <error> // <reason id=”301”>Moved Permanently</reason> // </error> ElementPtr reason = IMessageHelper::createElementWithText("reason", mErrorReason); if (0 != mErrorCode) { IMessageHelper::setAttributeID(reason, Stringize<WORD>(mErrorCode).string()); } ElementPtr error = IMessageHelper::createElement("error"); error->adoptAsLastChild(reason); root->adoptAsLastChild(error); return ret; }
ElementPtr Node::getRootElement() const { ElementPtr found; if (isElement()) { found = toElement(); } else { found = getParentElement(); } if (!found) return ElementPtr(); ElementPtr parent = found->getParentElement(); while (parent) { found = parent; parent = parent->getParentElement(); } return found; }
void Gamefield::addElement(ElementPtr const& elem) { { lock_guard<mutex> _lock(mMutexElements); mQuadTree->add(elem.get()); mElements.push_back(elem); } { lock_guard<mutex> _lock(mMutexNewElements); mNewElements.push_back(elem); } }
void XULParser::pushStack(ElementPtr inElement) { if (inElement) { if (mStack.empty()) { assert(!mRootElement); mRootElement = inElement; } mStack.push(inElement.get()); } }
Handle<Value> ElementJs::setStatusString(const Arguments& args) { HandleScope scope; try { QString statusStr = toCpp<QString>(args[0]); Status s = Status::fromString(statusStr); ElementPtr e = ObjectWrap::Unwrap<ElementJs>(args.This())->getElement(); e->setStatus(s); } catch ( const HootException& e ) { return v8::ThrowException(HootExceptionJs::create(e)); } return scope.Close(Undefined()); }
//--------------------------------------------------------------------- IdentityAccessWindowRequestPtr IdentityAccessWindowRequest::create( ElementPtr root, IMessageSourcePtr messageSource ) { IdentityAccessWindowRequestPtr ret(new IdentityAccessWindowRequest); MessageHelper::fill(*ret, root, messageSource); ElementPtr browserEl = root->findFirstChildElement("browser"); if (browserEl) { String ready = IMessageHelper::getElementText(browserEl->findFirstChildElement("ready")); if (!ready.isEmpty()) { ret->mReady = ("true" == ready ? 1 : 0); } String visibility = IMessageHelper::getElementText(browserEl->findFirstChildElement("visibility")); if (!visibility.isEmpty()) { ret->mVisible = ("true" == visibility ? 1 : 0); } } return ret; }
void OgrWriter::writeElement(ElementPtr &element, bool debug) { //Unfortunately, this check also has to happen in addition to checking hasMoreElements. See //explanation in ServicesDbReader::readNextElement. if (element.get()) { Tags sourceTags = element->getTags(); Tags destTags; for (Tags::const_iterator it = element->getTags().begin(); it != element->getTags().end(); ++it) { if (sourceTags[it.key()] != "") { destTags.appendValue(it.key(), it.value()); } } // Now that all the empties are gone, update our element element->setTags(destTags); if ( debug == true ) { LOG_DEBUG(element->toString()); } PartialOsmMapWriter::writePartial(element); } }
HTMLFormControlsCollectionImp::HTMLFormControlsCollectionImp(const HTMLFormElementPtr& form) : length(0) { ElementPtr i = form; while (i = i->getNextElement(form)) { if (isListedElement(i)) { std::u16string name; Nullable<std::u16string> a = i->getAttribute(u"name"); if (a.hasValue()) name = a.value(); if (name.empty()) { a = i->getAttribute(u"id"); if (a.hasValue()) name = a.value(); } Object found = namedItem(name); if (!found) { map.insert(std::pair<const std::u16string, Object>(name, i)); ++length; continue; } if (html::RadioNodeList::hasInstance(found)) { html::RadioNodeList r = interface_cast<html::RadioNodeList>(found); if (auto list = std::dynamic_pointer_cast<RadioNodeListImp>(r.self())) { list->addItem(i); ++length; } continue; } auto list = std::make_shared<RadioNodeListImp>(); if (list) { list->addItem(interface_cast<Element>(found)); list->addItem(i); ++length; map.erase(name); map.insert(std::pair<const std::u16string, Object>(name, list)); } } } }
PeerToPeerPeerIdentifyRequestPtr PeerToPeerPeerIdentifyRequest::create(ElementPtr root) { PeerToPeerPeerIdentifyRequestPtr ret(new message::PeerToPeerPeerIdentifyRequest); if (root) { try { ElementPtr el; ElementPtr proofEl = root->findFirstChildElementChecked("proofBundle")->findFirstChildElementChecked("proof"); ret->mID = IMessageHelper::getAttributeID(root); ret->mProofID = IMessageHelper::getAttributeID(proofEl); ret->mLocationID = IMessageHelper::getAttributeID(proofEl->findFirstChildElement("location")); ret->mFindSecret = IMessageHelper::getElementText(proofEl->findFirstChildElement("findSecret")); ret->mOneTimeKey = IMessageHelper::getAttributeID(proofEl->findFirstChildElement("oneTimeKey")); ret->mExpires = IMessageHelper::stringToTime(IMessageHelper::getElementText(proofEl->findFirstChildElement("expires"))); ret->mUserAgent = IMessageHelper::getElementTextAndEntityDecode(proofEl->findFirstChildElement("userAgent")); ret->mPeerFilePublic = IPeerFilePublic::loadFromXML(proofEl->findFirstChildElement("peer")); } catch (Exceptions::CheckFailed &e) {} } return ret; }
//--------------------------------------------------------------------- LockboxAccessResultPtr LockboxAccessResult::create( ElementPtr rootEl, IMessageSourcePtr messageSource ) { LockboxAccessResultPtr ret(new LockboxAccessResult); IMessageHelper::fill(*ret, rootEl, messageSource); ret->mLockboxInfo = MessageHelper::createLockbox(rootEl->findFirstChildElement("lockbox")); ret->mNamespaceGrantChallengeInfo = MessageHelper::createNamespaceGrantChallenge(rootEl->findFirstChildElement("namespaceGrantChallenge")); ElementPtr identitiesEl = rootEl->findFirstChildElement("identities"); if (identitiesEl) { ElementPtr identityEl = identitiesEl->findFirstChildElement("identity"); while (identityEl) { IdentityInfo info = MessageHelper::createIdentity(identityEl); if (info.hasData()) { ret->mIdentities.push_back(info); } identityEl = identityEl->findNextSiblingElement("identity"); } } return ret; }
void SimpleElementMapSerializer<KeyT>::Serialize(Archive& archive) const { V_Element components; components.resize(m_Data->size() * 2); { DataType::const_iterator itr = m_Data->begin(); DataType::const_iterator end = m_Data->end(); for ( int i = 0; itr != end; ++itr ) { if (!itr->second.ReferencesObject()) { continue; } ElementPtr elem; archive.GetCache().Create( Reflect::GetType<KeyT>(), elem ); Serializer* ser = AssertCast<Serializer>(elem.Ptr()); ser->ConnectData((void*)&(itr->first)); components[i++] = ser; components[i++] = itr->second; } } archive.Serialize(components); { V_Element::iterator itr = components.begin(); V_Element::iterator end = components.end(); for ( ; itr != end; ++itr ) { Serializer* ser = AssertCast<Serializer>(*itr); ser->Disconnect(); archive.GetCache().Free(ser); ++itr; } } }
PeerToFinderPeerLocationFindResultPtr PeerToFinderPeerLocationFindResult::create(ElementPtr root) { PeerToFinderPeerLocationFindResultPtr ret(new message::PeerToFinderPeerLocationFindResult); ret->mID = IMessageHelper::getAttributeID(root); ret->mTime = IMessageHelper::getAttributeEpoch(root); ElementPtr locs = root->findFirstChildElement("locations"); if (locs) { LocationList ll; ElementPtr loc = locs->findFirstChildElement("location"); while (loc) { Location l = MessageHelper::createLocation(loc->findFirstChildElement("details")); l.mID = IMessageHelper::getAttributeID(loc); ll.push_back(l); loc = loc->getNextSiblingElement(); } if (ll.size() > 0) ret->mLocations = ll; } return ret; }
MultiLineStringLocation PertyWaySplitVisitor::_calcSplitPoint(ConstRelationPtr relation, ElementId& wayId) const { const vector<RelationData::Entry>& members = relation->getMembers(); LOG_VART(members.size()); //find the way to split on boost::uniform_int<> randomWayIndexDistribution(0, members.size() - 1); int wayIndex = randomWayIndexDistribution(*_rng); wayId = members.at(wayIndex).getElementId(); LOG_VART(wayIndex); LOG_VART(wayId); ElementPtr element = _map->getElement(wayId); if (element->getElementType() != ElementType::Way) { throw HootException( "PERTY feature splitting for multi-line string relations may only occur on relations which contain only ways."); } WayPtr way = boost::dynamic_pointer_cast<Way>(element); LOG_VART(way->getNodeCount()); //calculate the split point WayLocation wayLocation = _calcSplitPoint(way); //return it, if its valid if (wayLocation.isValid()) { return MultiLineStringLocation( _map->shared_from_this(), relation, wayIndex, wayLocation); } //otherwise, return an empty location else { return MultiLineStringLocation(); } }
//--------------------------------------------------------------------- LockboxIdentitiesUpdateResultPtr LockboxIdentitiesUpdateResult::create( ElementPtr root, IMessageSourcePtr messageSource ) { LockboxIdentitiesUpdateResultPtr ret(new LockboxIdentitiesUpdateResult); IMessageHelper::fill(*ret, root, messageSource); ElementPtr identitiesEl = root->findFirstChildElement("identities"); if (identitiesEl) { ElementPtr identityEl = identitiesEl->findFirstChildElement("identity"); while (identityEl) { IdentityInfo info = MessageHelper::createIdentity(identityEl); if (info.hasData()) { ret->mIdentities.push_back(info); } identityEl = identityEl->findNextSiblingElement("identity"); } } return ret; }
DocumentPtr ProviderAssociateURLGetRequest::encode(message::ProviderAssociateURLGetRequest &msg) { DocumentPtr ret = IMessageHelper::createDocumentWithRoot(msg); ElementPtr root = ret->getFirstChildElement(); if (msg.hasAttribute(message::ProviderAssociateURLGetRequest::AttributeType_ProviderType)) { root->adoptAsLastChild(IMessageHelper::createElementWithText("providerType", provisioning::IAccount::toCodeString(msg.mProviderType))); } if (msg.hasAttribute(message::ProviderAssociateURLGetRequest::AttributeType_UserID)) { root->adoptAsLastChild(IMessageHelper::createElementWithText("userID", msg.mUserID)); } if (msg.hasAttribute(message::ProviderAssociateURLGetRequest::AttributeType_AccessKey)) { root->adoptAsLastChild(IMessageHelper::createElementWithText("accessKey", msg.mAccessKey)); } if (msg.hasAttribute(message::ProviderAssociateURLGetRequest::AttributeType_AccessSecret)) { root->adoptAsLastChild(IMessageHelper::createElementWithText("accessSecret", msg.mAccessSecret)); } return ret; }
//--------------------------------------------------------------------- PeerKeepAliveResultPtr PeerKeepAliveResult::create( ElementPtr root, IMessageSourcePtr messageSource ) { PeerKeepAliveResultPtr ret(new PeerKeepAliveResult); ret->mID = IMessageHelper::getAttributeID(root); ret->mTime = IMessageHelper::getAttributeEpoch(root); ret->mExpires = IHelper::stringToTime(IMessageHelper::getElementText(root->findFirstChildElement("expires"))); return ret; }
DocumentPtr ProviderLoginURLGetRequest::encode(message::ProviderLoginURLGetRequest &msg) { DocumentPtr ret = IMessageHelper::createDocumentWithRoot(msg); ElementPtr root = ret->getFirstChildElement(); if (msg.hasAttribute(message::ProviderLoginURLGetRequest::AttributeType_ProviderType)) { root->adoptAsLastChild(IMessageHelper::createElementWithText("providerType", provisioning::IAccount::toCodeString(msg.mProviderType))); } if (msg.hasAttribute(message::ProviderLoginURLGetRequest::AttributeType_DeviceUUID)) { root->adoptAsLastChild(IMessageHelper::createElementWithText("deviceUUID", msg.mDeviceUUID)); } if (msg.hasAttribute(message::ProviderLoginURLGetRequest::AttributeType_DeviceToken)) { root->adoptAsLastChild(IMessageHelper::createElementWithText("deviceToken", msg.mDeviceToken)); } if (msg.hasAttribute(message::ProviderLoginURLGetRequest::AttributeType_AccountSalt)) { root->adoptAsLastChild(IMessageHelper::createElementWithText("accountSalt", msg.mAccountSalt)); } return ret; }
void SyncTestbed::CompareElementRecurs(const ElementPtr& element1, const ElementPtr& element2) const { Assert::AreEqual(element1->GetName()->GetString(), element2->GetName()->GetString()); Assert::IsTrue(element1->GetGUID() == element2->GetGUID()); Assert::IsTrue(element1->GetElementType() == element2->GetElementType()); Assert::IsTrue(element1->GetXValue() == element2->GetXValue()); if (element1->GetElementType() == ElementType::ObjectType) { ObjectElementPtr objElement1 = ObjectElement::Cast(element1); Assert::IsNotNull(objElement1.get()); ObjectElementPtr objElement2 = ObjectElement::Cast(element2); Assert::IsNotNull(objElement2.get()); Assert::AreEqual(objElement1->GetElementCount(), objElement2->GetElementCount()); for (int32 i = 0; i < objElement1->GetElementCount(); ++i) { ElementPtr childElement1 = objElement1->GetElementAt(i); ElementPtr childElement2 = objElement2->GetElement(childElement1->GetName()); Assert::IsNotNull(childElement2.get()); CompareElementRecurs(childElement1, childElement2); } } else if (IsFrom<ArrayElement>(element1)) { ArrayElement* arrayElement1 = reflection_cast<ArrayElement>(element1); Assert::IsNotNull(arrayElement1); ArrayElement* arrayElement2 = reflection_cast<ArrayElement>(element2); Assert::IsNotNull(arrayElement2); Assert::AreEqual(arrayElement1->GetCount(), arrayElement2->GetCount()); for (int32 i = 0; i < arrayElement1->GetCount(); ++i) { Assert::IsTrue(arrayElement1->GetXValue(i) == arrayElement2->GetXValue(i)); } } }
map< int, vector<DofInfo> > constructGlobalDofToLocalDofInfoMap(MeshPtr mesh) { // go through the mesh as a whole, and collect info for each dof map< int, vector<DofInfo> > infoMap; DofInfo info; set<GlobalIndexType> activeCellIDs = mesh->getActiveCellIDsGlobal(); for (set<GlobalIndexType>::iterator cellIt = activeCellIDs.begin(); cellIt != activeCellIDs.end(); cellIt++) { GlobalIndexType cellID = *cellIt; info.cellID = cellID; ElementPtr element = mesh->getElement(cellID); DofOrderingPtr trialOrder = element->elementType()->trialOrderPtr; set<int> trialIDs = trialOrder->getVarIDs(); info.totalDofs = trialOrder->totalDofs(); for (set<int>::iterator trialIt=trialIDs.begin(); trialIt != trialIDs.end(); trialIt++) { info.trialID = *trialIt; const vector<int>* sidesForVar = &trialOrder->getSidesForVarID(info.trialID); for (vector<int>::const_iterator sideIt = sidesForVar->begin(); sideIt != sidesForVar->end(); sideIt++) { int sideIndex = *sideIt; info.sideIndex = sideIndex; info.basisCardinality = trialOrder->getBasisCardinality(info.trialID, info.sideIndex); for (int basisOrdinal=0; basisOrdinal < info.basisCardinality; basisOrdinal++) { info.basisOrdinal = basisOrdinal; info.localDofIndex = trialOrder->getDofIndex(info.trialID, info.basisOrdinal, info.sideIndex); pair<int, int> localDofIndexKey = make_pair(info.cellID, info.localDofIndex); int globalDofIndex = mesh->getLocalToGlobalMap().find(localDofIndexKey)->second; // cout << "(" << info.cellID << "," << info.localDofIndex << ") --> " << globalDofIndex << endl; infoMap[globalDofIndex].push_back(info); } } } } return infoMap; }