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 MojDb::mergeInto(MojObject& dest, const MojObject& obj, const MojObject& prev)
{
MojLogTrace(s_log);
// TODO: support field deletion
// TODO: move merge fn out of db
MojErr err;
MojObject::ConstIterator objIter = obj.begin();
MojObject::ConstIterator prevIter = prev.begin();
while (objIter != obj.end() || prevIter != prev.end()) {
// compare keys from two iters
int comp;
if (objIter == obj.end()) {
comp = 1;
} else if (prevIter == prev.end()) {
comp = -1;
} else {
comp = objIter.key().compare(prevIter.key());
}
// put the appropriate value into dest
if (comp > 0) {
err = dest.put(prevIter.key(), prevIter.value());
MojErrCheck(err);
++prevIter;
} else if (comp < 0) {
err = dest.put(objIter.key(), objIter.value());
MojErrCheck(err);
++objIter;
} else {
MojObject::Type newType = objIter.value().type();
MojObject::Type prevType = prevIter.value().type();
if (newType == MojObject::TypeObject && prevType == MojObject::TypeObject) {
MojObject merged(MojObject::TypeObject);
err = mergeInto(merged, objIter.value(), prevIter.value());
MojErrCheck(err);
err = dest.put(objIter.key(), merged);
MojErrCheck(err);
} else {
err = dest.put(objIter.key(), objIter.value());
MojErrCheck(err);
}
++prevIter;
++objIter;
}
}
return MojErrNone;
}
MojErr MojLogEngine::configure(const MojObject& conf, const MojChar* name)
{
MojAssert(name);
MojErr err = MojErrNone;
MojLogger::Level defaultLevel = MojLogger::LevelDefault;
MojAutoPtr<MojLogAppender> appender;
LevelMap levels;
// validate entire configuration before we apply any changes
MojObject logConf;
if (conf.get(LogKey, logConf)) {
// appender
MojObject obj;
if (logConf.get(AppenderKey, obj)) {
err = createAppender(obj, name, appender);
MojErrCheck(err);
}
// levels
if (logConf.get(LevelsKey, obj)) {
// configure loggers
MojString str;
for (MojObject::ConstIterator i = obj.begin(); i != obj.end(); ++i) {
MojLogger::Level level = MojLogger::LevelNone;
err = i.value().stringValue(str);
MojErrCheck(err);
err = MojLogger::levelFromString(str, level);
MojErrCheck(err);
if (i.key() == DefaultKey) {
defaultLevel = level;
} else {
err = levels.put(i.key(), level);
MojErrCheck(err);
}
}
}
}
// apply changes
MojThreadGuard guard(m_mutex);
// update name
err = m_name.assign(name);
MojErrCheck(err);
// update appender
updateAppender(appender);
// update levels
m_levels = levels;
m_defaultLogger.level(defaultLevel);
updateLoggers();
return MojErrNone;
}
MojErr MojDbPropExtractor::valsImpl(const MojObject& obj, KeySet& valsOut, MojSize idx) const
{
LOG_TRACE("Entering function %s", __FUNCTION__);
MojAssert(!m_prop.empty() && idx < m_prop.size());
MojErr err = MojErrNone;
const MojString& propKey = m_prop[idx];
if (propKey == WildcardKey) {
// get all prop vals if we have a wildcard
for (MojObject::ConstIterator i = obj.begin(); i != obj.end(); ++i) {
err = handleVal(*i, valsOut, idx);
MojErrCheck(err);
}
} else {
// get object corresponding to the current component in the prop path
MojObject::ConstIterator i = obj.find(propKey);
if (i == obj.end()) {
err = valsOut.put(m_default);
MojErrCheck(err);
} else {
if (i->type() == MojObject::TypeArray) {
// if the value is an array, act on its elements rather than the array object itself
MojObject::ConstArrayIterator end = i->arrayEnd();
for (MojObject::ConstArrayIterator j = i->arrayBegin(); j != end; ++j) {
err = handleVal(*j, valsOut, idx);
MojErrCheck(err);
}
} else {
// not an array
err = handleVal(*i, valsOut, idx);
MojErrCheck(err);
}
}
}
return MojErrNone;
}
MojoObjectString::MojoObjectString(const MojObject& obj, const MojChar *key)
{
MojErr err;
MojObject::ConstIterator found = obj.find(key);
if (found != obj.end()) {
err = found.value().stringValue(m_str);
if (err) {
m_str.assign("(error retreiving value)");
}
} else {
m_str.assign("(not found)");
}
}