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