MojErr MojObjectFilter::init(const StringSet& selectProps) { MojAssert(m_root.get() == NULL); //create the root node m_root.reset(new Node(MojString())); MojAllocCheck(m_root.get()); for (StringSet::ConstIterator i = selectProps.begin(); i != selectProps.end(); i++) { MojVector<MojString> parts; MojErr err = i->split(_T('.'), parts); MojErrCheck(err); Node* curNode = m_root.get(); for (MojVector<MojString>::ConstIterator pi = parts.begin(); pi != parts.end(); ++pi) { Node* child = curNode->find(*pi); if (child) { if (child->m_children.empty()) { break; } else { curNode = child; } } else { MojAutoPtr<Node> node(new Node(*pi)); MojAllocCheck(node.get()); Node* nextNode = node.get(); MojErr err = curNode->addChild(node); MojErrCheck(err); curNode = nextNode; } } } return MojErrNone; }
/* * Unformat the from address - removes blanks and converts to lower case * * see IMAddressFormatter.unformat() - palm.com.messaging.data */ MojErr IMMessage::unformatFromAddress(const MojString formattedScreenName, MojString& unformattedName) { if(!formattedScreenName.empty()) { MojVector<MojString> stringTokens; MojErr err = formattedScreenName.split(' ', stringTokens); MojErrCheck(err); MojVector<MojString>::ConstIterator itr = stringTokens.begin(); while (itr != stringTokens.end()) { err = unformattedName.append(*itr); MojErrCheck(err); itr++; } err = unformattedName.toLower(); MojErrCheck(err); } return MojErrNone; }
MojErr MojThreadTest::basicTest() { MojVector<MojThreadT> threads; MojThreadTestArgs args; for (int i = 0; i < MojTestNumThreads; ++i) { MojThreadT thread = MojInvalidThread; MojErr err = MojThreadCreate(thread, MojThreadTestFn, &args); MojTestErrCheck(err); MojTestAssert(thread != MojInvalidThread); err = threads.push(thread); MojTestErrCheck(err); } { MojThreadGuard guard(args.m_mutex); while (args.m_counter < (MojTestNumThreads * MojTestNumIterations)) { MojErr err = args.m_countCond.wait(args.m_mutex); MojErrCheck(err); } MojTestAssert(args.m_counter == (MojTestNumThreads * MojTestNumIterations)); MojTestAssert(args.m_atomicCounter == (MojTestNumThreads * MojTestNumIterations)); guard.unlock(); MojErr err = MojSleep(MojMillisecs(500)); MojTestErrCheck(err); guard.lock(); args.m_wait = false; err = args.m_waitCond.broadcast(); MojTestErrCheck(err); } for (MojVector<MojThreadT>::ConstIterator i = threads.begin(); i != threads.end(); ++i) { MojErr threadErr = MojErrNone; MojErr err = MojThreadJoin(*i, threadErr); MojTestErrCheck(err); MojTestErrCheck(threadErr); } MojTestAssert(args.m_counter == 0); MojTestAssert(args.m_atomicCounter == 0); return MojErrNone; }
MojErr MojDb::dump(const MojChar* path, MojUInt32& countOut, bool incDel, MojDbReqRef req, bool backup, MojUInt32 maxBytes, const MojObject* incrementalKey, MojObject* backupResponse) { MojAssert(path); MojLogTrace(s_log); MojErr err = beginReq(req); MojErrCheck(err); if (!req->admin()) { MojLogError(s_log, _T("access denied: '%s' cannot dump db to path: '%s'"), req->domain().data(), path); MojErrThrow(MojErrDbAccessDenied); } MojFile file; err = file.open(path, MOJ_O_WRONLY | MOJ_O_CREAT | MOJ_O_TRUNC, MOJ_S_IRUSR | MOJ_S_IWUSR); MojErrCheck(err); // write out kinds first, then existing objects, then deleted objects MojSize bytesWritten = 0; MojSize totalwarns = 0; MojSize newwarns = 0; MojDbQuery objQuery; MojVector<MojObject> kindVec; MojObject revParam = -1; MojObject delRevParam = -1; // if we were given an incremental key, pull out the revs now if (incrementalKey) { incrementalKey->get(MojDbServiceDefs::RevKey, revParam); incrementalKey->get(MojDbServiceDefs::DeletedRevKey, delRevParam); } err = m_kindEngine.getKinds(kindVec); MojErrCheck(err); // write kinds - if incremental, only write the kinds that have changed since the respective revs MojString countStr; for (MojVector<MojObject>::ConstIterator i = kindVec.begin(); i != kindVec.end(); ++i) { if (backup) { bool backupKind = false; i->get(MojDbKind::SyncKey, backupKind); if (!backupKind) continue; MojString id; err = i->getRequired(MojDbServiceDefs::IdKey, id); MojErrCheck(err); MojDbQuery countQuery; err = countQuery.from(id); MojErrCheck(err); MojDbCursor cursor; err = find(countQuery, cursor, req); MojErrCheck(err); MojUInt32 count = 0; err = cursor.count(count); MojErrCheck(err); if (count > 0) { if (i != kindVec.begin()) { err = countStr.appendFormat(_T(", ")); MojErrCheck(err); } err = countStr.appendFormat("%s=%u", id.data(), count); MojErrCheck(err); } } bool deleted = false; i->get(DelKey, deleted); MojObject kindRev; err = i->getRequired(RevKey, kindRev); MojErrCheck(err); if ((deleted && kindRev > delRevParam) || (!deleted && kindRev > revParam)) { err = dumpObj(file, (*i), bytesWritten, maxBytes); MojErrCheck(err); countOut++; } } // dump all the non-deleted objects err = dumpImpl(file, backup, false, revParam, delRevParam, true, countOut, req, backupResponse, MojDbServiceDefs::RevKey, bytesWritten, newwarns, maxBytes); MojErrCheck(err); totalwarns += newwarns; // If we're supposed to include deleted objects, dump the deleted objects now. // There's a chance that we may have run out of space in our backup. If that's the case, // we don't want to try to dump deleted objects - we can detect this by looking for the HasMoreKey if (incDel && backupResponse && !backupResponse->contains(MojDbServiceDefs::HasMoreKey)) { err = dumpImpl(file, backup, true, revParam, delRevParam, false, countOut, req, backupResponse, MojDbServiceDefs::DeletedRevKey, bytesWritten, newwarns, maxBytes); MojErrCheck(err); } totalwarns += newwarns; // Add the Full and Version keys if (backup && backupResponse) { bool incremental = (incrementalKey != NULL); err = backupResponse->putBool(MojDbServiceDefs::FullKey, !incremental); MojErrCheck(err); err = backupResponse->put(MojDbServiceDefs::VersionKey, DatabaseVersion); MojErrCheck(err); err = backupResponse->put(MojDbServiceDefs::WarningsKey, (MojInt32)totalwarns); MojErrCheck(err); MojString description; err = description.format(_T("incremental=%u"), countOut); MojErrCheck(err); if (!countStr.empty()) { err = description.appendFormat(_T(", %s"), countStr.data()); MojErrCheck(err); } err = backupResponse->put(_T("description"), description); MojErrCheck(err); } err = req->end(); MojErrCheck(err); return MojErrNone; }