C++ MojObject::del方法代码示例

MojErr MojDbPerfUpdateTest::timeUpdateKind(MojDb& db, const MojChar* kindJson, MojObject& kindObj, MojTime& addIndexTime, MojTime& dropIndexTime)
{
	MojTime startTime;
	MojTime endTime;
	MojObject origKindObj;
	MojErr err = origKindObj.fromJson(kindJson);
	MojTestErrCheck(err);

	for (MojUInt64 i = 0; i < numUpdateKindIterations; i++) {
		err = MojGetCurrentTime(startTime);
		MojTestErrCheck(err);
		bool found;
		err = kindObj.del(MojDb::RevKey, found);
		MojTestErrCheck(err);
		err = db.putKind(kindObj);
		MojTestErrCheck(err);
		err = MojGetCurrentTime(endTime);
		MojTestErrCheck(err);
		addIndexTime += (endTime - startTime);
		totalTestTime += (endTime - startTime);

		err = MojGetCurrentTime(startTime);
		MojTestErrCheck(err);
		err = origKindObj.del(MojDb::RevKey, found);
		MojTestErrCheck(err);
		err = db.putKind(origKindObj);
		MojTestErrCheck(err);
		err = MojGetCurrentTime(endTime);
		MojTestErrCheck(err);
		dropIndexTime += (endTime - startTime);
		totalTestTime += (endTime - startTime);
	}

	return MojErrNone;
}

MojErr MojObjectTest::emptyTest(MojObject& obj)
{
    MojObject obj2;
    MojString str1;
    MojString str2;

    bool found = false;

    MojTestAssert(obj.size() == 0);
    MojTestAssert(obj.empty());
    MojTestAssert(obj.boolValue() == false);
    MojTestAssert(obj.intValue() == 0);
    MojTestAssert(obj.decimalValue() == MojDecimal());

    MojTestAssert(obj.begin() == obj.end());
    MojTestAssert(!obj.contains(_T("hello")));
    MojTestAssert(!obj.get(_T("hi"), obj2));
    MojErr err = obj.del(_T("hello"), found);
    MojTestErrCheck(err);

    obj2.assign(obj);
    MojTestAssert(obj2.type() == obj.type());
    MojTestAssert(obj2 == obj);
    MojTestAssert(!(obj2 != obj));

    err = obj.stringValue(str1);
    MojTestErrCheck(err);
    err = obj2.stringValue(str2);
    MojTestErrCheck(err);
    MojTestAssert(str1 == str2);

    return MojErrNone;
}

MojErr MojDbSearchCache::QueryKey::setQuery(const MojDbQuery& query)
{
    MojObject obj;
    MojErr err = query.toObject(obj);
    MojErrCheck(err);

    bool foundOut=false;
    obj.del(MojDbQuery::PageKey, foundOut);
    obj.del(MojDbQuery::LimitKey, foundOut);

    err = obj.toJson(m_query);
    MojErrCheck(err);

    setKind(query.from());
    return err;
}

    MojErr Response(MojObject& response, MojErr err)
    {
        bool success = true;
        bool getSuccess = response.get("returnValue", success);

        if (err || !getSuccess || !success) {
            // unfortunately file cache doesn't use regular C++ mojo error codes
            // & more unfortunately all the various failure reasons for define are hidden
            // behind 1 error code
            MojInt64 errorCode;
            if (response.get("errorCode", errorCode)) {
                FileCacheFailure failure = (FileCacheFailure)errorCode;
                // be generous in the error code that can be used
                if (failure == FCDefineError || failure == FCExistsError) {
                    MojString mojErrorText;
                    string errorText;
                    std::string nakOkSuffix = "' already exists.";

                    response.getRequired("errorText", mojErrorText);
                    errorText = mojErrorText.data();

                    if (endsWith(errorText, nakOkSuffix)) {
                        LOG_DEBUG("caching negative response for %s", m_config.c_str());
                        bool found = false;
                        response.del("errorCode", found);
                        response.del("errorText", found);
                        err = response.putBool("returnValue", true);
                        MarkConfigured();
                    } else {
                        LOG_WARNING(MSGID_FILE_CACHE_CONFIG_WARNING, 2,
                                    PMLOGKS("error", errorText.c_str()),
                                    PMLOGKS("suffix", nakOkSuffix.c_str()),
                                    "File cache failed to register type (`%s' doesn't end with `%s'", errorText.c_str(), nakOkSuffix.c_str());
                    }
                } else {
                    LOG_WARNING(MSGID_FILE_CACHE_CONFIG_WARNING, 1,
                                PMLOGKFV("error", "%d", (int)errorCode),
                                "Unrecognized errorCode %d", (int)errorCode);
                }
            } else {
                LOG_WARNING(MSGID_FILE_CACHE_CONFIG_WARNING, 0, "errorCode not provided in request failure");
            }
        } else {
            LOG_DEBUG("FileCacheConfigurator response for %s contained no problems", m_config.c_str());
        }
        return DelegateResponse(response, err);
    }

MojErr MojDbKindState::delIndex(const MojChar* indexName, MojDbReq& req)
{
	MojAssert(indexName);
	MojThreadGuard guard(m_lock);

	MojObject obj;
	MojRefCountedPtr<MojDbStorageItem> item;
	MojErr err = readIds(IndexIdsKey, req, obj, item);
	MojErrCheck(err);
	bool found = false;
	err = obj.del(indexName, found);
    MojErrCheck(err);
	MojAssert(found);
	err = writeIds(IndexIdsKey, obj, req, item);
	MojErrCheck(err);

	return MojErrNone;
}

void SaveEmailCommand::WriteToFileCache(MojObject &part, const MojString &pathName)
{
	MojErr err;
	MojString content;
	err = part.getRequired("content", content);
	ErrorToException(err);
	
	// FIXME: make this async
	FILE *fp = fopen(pathName.data(), "w");
	if(fp) {
		fwrite(content.data(), sizeof(MojChar), content.length(), fp);
		fclose(fp);
	} else {
		throw MailException("error opening file cache path", __FILE__, __LINE__);
	}
	
	// Cancel subscription to signal that we're done writing
	m_fileCacheInsertedSlot.cancel();

	MojString type;
	err = part.getRequired(EmailSchema::Part::TYPE, type);
	ErrorToException(err);

	if (type == EmailSchema::Part::Type::BODY) {
		std::string previewText = PreviewTextGenerator::GeneratePreviewText(content.data(), MAX_SUMMARY_LENGTH, true);
		err = m_email.putString(EmailSchema::SUMMARY, previewText.c_str());
		ErrorToException(err);
	}

	// Delete content field so it doesn't get written to the database
	bool wasDeleted;
	part.del("content", wasDeleted);
	
	// Next step
	if(m_partsIt == m_partsArray.arrayEnd())
		PersistToDatabase(); // done
	else
		CreateNextCacheObject(); // more parts remaining
	
	return;
}

/**
 * Log the json for an incoming IM payload so we can troubleshoot errors in the field in
 * non debug builds.
 *
 * removes "private" data - ie. message body
 */
MojErr IMServiceHandler::privatelogIMMessage(const MojChar* format, MojObject IMObject, const MojChar* messageTextKey) {

	MojString mojStringJson;
	MojString msgText;

	// replace the message body
	// not much we can do about errors here...

	bool found = false;
	MojErr err = IMObject.del(messageTextKey, found);
	MojErrCheck(err);
	if (found) {
		msgText.assign(_T("***IM Body Removed***"));
		IMObject.put(messageTextKey, msgText);
	}

	// log it (non debug)
	IMObject.toJson(mojStringJson);
	MojLogNotice(IMServiceApp::s_log, format, mojStringJson.data());

	return MojErrNone;
}

MojErr MojDb::dumpObj(MojFile& file, MojObject obj, MojSize& bytesWrittenOut, MojUInt32 maxBytes)
{
	// remove the rev key before dumping the object
	bool found = false;
	MojErr err = obj.del(RevKey, found);
	MojErrCheck(err);

	MojString str;
	err = obj.toJson(str);
	MojErrCheck(err);
	err = str.append(_T("\n"));
	MojErrCheck(err);
	MojSize len = str.length() * sizeof(MojChar);
	// if writing this object will put us over the max length, throw an error
	if (maxBytes && bytesWrittenOut + len > maxBytes) {
		MojErrThrow(MojErrDbBackupFull);
	}
	err = file.writeString(str, bytesWrittenOut);
	MojErrCheck(err);

	return MojErrNone;
}

	MojErr Response(MojObject& response, MojErr err)
	{
		bool success = true;
		response.get("returnValue", success);

		if (err || !success) {
			MojInt64 errorCode;
			if (response.get("errorCode", errorCode)) {
				if (errorCode == MojErrExists) {
					MojLogInfo(Logger(), "caching ok negative response for %s", m_config.c_str());
					bool found = false;
					response.del("errorCode", found);
					response.del("errorText", found);
					err = response.putBool("returnValue", true);
					MarkConfigured();
				} else {
					MojLogWarning(Logger(), "Unrecognized errorCode %d", (int)errorCode);
				}
			} else {
				MojLogWarning(Logger(), "errorCode not provided in request failure");
			}
		}
		return DelegateResponse(response, err);
	}

static void RemoveKey(MojObject& object, const MojChar *key)
{
	bool keydeleted;
	object.del(key, keydeleted);
}