MojoNewWhereMatcher::MatchResult MojoNewWhereMatcher::CheckProperty(
const MojObject& keyArray, MojObject::ConstArrayIterator keyIter,
const MojObject& response, const MojObject& op, const MojObject& val,
MatchMode mode) const
{
MojObject onion = response;
for (; keyIter != keyArray.arrayEnd(); ++keyIter) {
if (onion.type() == MojObject::TypeArray) {
return CheckProperty(keyArray, keyIter, onion, onion.arrayBegin(),
op, val, mode);
} else if (onion.type() == MojObject::TypeObject) {
MojString keyStr;
MojErr err = (*keyIter).stringValue(keyStr);
if (err) {
throw std::runtime_error("Failed to convert property lookup "
"key to string");
}
MojObject next;
if (!onion.get(keyStr.data(), next)) {
return NoProperty;
}
onion = next;
} else {
return NoProperty;
}
}
return CheckMatch(onion, op, val);
}
boost::shared_ptr<Requirement> ConnectionManagerProxy::InstantiateRequirement(
boost::shared_ptr<Activity> activity, const std::string& name,
const MojObject& value)
{
LOG_TRACE("Entering function %s", __FUNCTION__);
LOG_DEBUG("Instantiating [Requirement %s] for [Activity %llu]",
name.c_str(), activity->GetId());
if (name == "internet") {
if ((value.type() == MojObject::TypeBool) && value.boolValue()) {
boost::shared_ptr<ListedRequirement> req =
boost::make_shared<BasicCoreListedRequirement>(
activity, m_internetRequirementCore,
m_internetRequirementCore->IsMet());
m_internetRequirements.push_back(*req);
return req;
} else {
throw std::runtime_error("If an 'internet' requirement is "
"specified, the only legal value is 'true'");
}
} else if (name == "internetConfidence") {
return InstantiateConfidenceRequirement(activity,
m_internetConfidenceCores, m_internetConfidenceRequirements,
value);
} else if (name == "wan") {
if ((value.type() == MojObject::TypeBool) && value.boolValue()) {
boost::shared_ptr<ListedRequirement> req =
boost::make_shared<BasicCoreListedRequirement>(
activity, m_wanRequirementCore,
m_wanRequirementCore->IsMet());
m_wanRequirements.push_back(*req);
return req;
} else {
throw std::runtime_error("If an 'wan' requirement is "
"specified, the only legal value is 'true'");
}
} else if (name == "wanConfidence") {
return InstantiateConfidenceRequirement(activity, m_wanConfidenceCores,
m_wanConfidenceRequirements, value);
} else if (name == "wifi") {
if ((value.type() == MojObject::TypeBool) && value.boolValue()) {
boost::shared_ptr<ListedRequirement> req =
boost::make_shared<BasicCoreListedRequirement>(
activity, m_wifiRequirementCore,
m_wifiRequirementCore->IsMet());
m_wifiRequirements.push_back(*req);
return req;
} else {
throw std::runtime_error("If an 'wifi' requirement is "
"specified, the only legal value is 'true'");
}
} else if (name == "wifiConfidence") {
return InstantiateConfidenceRequirement(activity, m_wifiConfidenceCores,
m_wifiConfidenceRequirements, value);
} else {
LOG_ERROR(MSGID_REQUIREMENT_INSTANTIATE_FAIL , 3, PMLOGKS("Manager",GetName().c_str()),
PMLOGKFV("Activity","%llu",activity->GetId()), PMLOGKS("Requirement",name.c_str()), "");
throw std::runtime_error("Attempt to instantiate unknown requirement");
}
}
MojoNewWhereMatcher::MatchResult MojoNewWhereMatcher::CheckProperty(
const MojObject& key, const MojObject& response, const MojObject& op,
const MojObject& val, MatchMode mode) const
{
if (key.type() == MojObject::TypeString) {
MojString keyStr;
MojErr err = key.stringValue(keyStr);
if (err) {
throw std::runtime_error("Failed to convert property lookup key "
"to string");
}
MojObject propVal;
bool found = response.get(keyStr.data(), propVal);
if (!found) {
return NoProperty;
}
return CheckMatch(propVal, op, val);
} else if (key.type() == MojObject::TypeArray) {
return CheckProperty(key, key.arrayBegin(), response, op, val, mode);
} else {
throw std::runtime_error("Key specified was neither a string or "
"array of strings");
}
}
boost::shared_ptr<Requirement> PowerdProxy::InstantiateRequirement(
boost::shared_ptr<Activity> activity, const std::string& name,
const MojObject& value)
{
LOG_TRACE("Entering function %s", __FUNCTION__);
LOG_DEBUG("Instantiating [Requirement %s] for [Activity %llu]",
name.c_str(), activity->GetId());
if (name == "charging") {
if ((value.type() != MojObject::TypeBool) || !value.boolValue()) {
throw std::runtime_error("A \"charging\" requirement must specify "
"'true' if present");
}
boost::shared_ptr<ListedRequirement> req =
boost::make_shared<BasicCoreListedRequirement>(
activity, m_chargingRequirementCore,
m_chargingRequirementCore->IsMet());
m_chargingRequirements.push_back(*req);
return req;
} else if (name == "docked") {
if ((value.type() != MojObject::TypeBool) || !value.boolValue()) {
throw std::runtime_error("A \"docked\" requirement must specify "
"'true' if present");
}
boost::shared_ptr<ListedRequirement> req =
boost::make_shared<BasicCoreListedRequirement>(
activity, m_dockedRequirementCore,
m_dockedRequirementCore->IsMet());
m_dockedRequirements.push_back(*req);
return req;
} else if (name == "battery") {
if ((value.type() != MojObject::TypeInt) ||
(value.intValue() < 0) || (value.intValue() > 100)) {
throw std::runtime_error("A \"battery\" requirement must specify "
"a value between 0 and 100");
}
MojInt64 percent = value.intValue();
boost::shared_ptr<BatteryRequirement> req =
boost::make_shared<BatteryRequirement>(activity, percent,
boost::dynamic_pointer_cast<PowerdProxy,
RequirementManager>(shared_from_this()),
(m_batteryPercent >= percent));
m_batteryRequirements.insert(*req);
return req;
} else {
LOG_ERROR(MSGID_UNKNOW_REQUIREMENT,3,
PMLOGKS("MANAGER",GetName().c_str()),
PMLOGKS("REQUIREMENT",name.c_str()),
PMLOGKFV("Activity","%llu",activity->GetId()),
"does not know how to instantiate ");
throw std::runtime_error("Attempt to instantiate unknown requirement");
}
}
boost::shared_ptr<Requirement> PowerdProxy::InstantiateRequirement(
boost::shared_ptr<Activity> activity, const std::string& name,
const MojObject& value)
{
MojLogTrace(s_log);
MojLogInfo(s_log, _T("Instantiating [Requirement %s] for [Activity %llu]"),
name.c_str(), activity->GetId());
if (name == "charging") {
if ((value.type() != MojObject::TypeBool) || !value.boolValue()) {
throw std::runtime_error("A \"charging\" requirement must specify "
"'true' if present");
}
boost::shared_ptr<ListedRequirement> req =
boost::make_shared<BasicCoreListedRequirement>(
activity, m_chargingRequirementCore,
m_chargingRequirementCore->IsMet());
m_chargingRequirements.push_back(*req);
return req;
} else if (name == "docked") {
if ((value.type() != MojObject::TypeBool) || !value.boolValue()) {
throw std::runtime_error("A \"docked\" requirement must specify "
"'true' if present");
}
boost::shared_ptr<ListedRequirement> req =
boost::make_shared<BasicCoreListedRequirement>(
activity, m_dockedRequirementCore,
m_dockedRequirementCore->IsMet());
m_dockedRequirements.push_back(*req);
return req;
} else if (name == "battery") {
if ((value.type() != MojObject::TypeInt) ||
(value.intValue() < 0) || (value.intValue() > 100)) {
throw std::runtime_error("A \"battery\" requirement must specify "
"a value between 0 and 100");
}
MojInt64 percent = value.intValue();
boost::shared_ptr<BatteryRequirement> req =
boost::make_shared<BatteryRequirement>(activity, percent,
boost::dynamic_pointer_cast<PowerdProxy,
RequirementManager>(shared_from_this()),
(m_batteryPercent >= percent));
m_batteryRequirements.insert(*req);
return req;
} else {
MojLogError(s_log, _T("[Manager %s] does not know how to instantiate "
"[Requirement %s] for [Activity %llu]"), GetName().c_str(),
name.c_str(), activity->GetId());
throw std::runtime_error("Attempt to instantiate unknown requirement");
}
}
MojoNewWhereMatcher::MatchResult MojoNewWhereMatcher::CheckClause(
const MojObject& clause, const MojObject& response, MatchMode mode) const
{
LOG_AM_TRACE("Entering function %s", __FUNCTION__);
if (clause.type() == MojObject::TypeArray) {
return CheckClauses(clause, response, mode);
} else if (clause.type() != MojObject::TypeObject) {
throw std::runtime_error("Clauses must be either an object or array "
"of objects");
}
LOG_AM_DEBUG("Checking clause '%s' against response '%s' (%s)",
MojoObjectJson(clause).c_str(), MojoObjectJson(response).c_str(),
(mode == AndMode) ? "and" : "or");
if (clause.contains(_T("and"))) {
MojObject andClause;
clause.get(_T("and"), andClause);
return CheckClause(andClause, response, AndMode);
} else if (clause.contains(_T("or"))) {
MojObject orClause;
clause.get(_T("or"), orClause);
return CheckClause(orClause, response, OrMode);
}
MojObject prop;
bool found = clause.get(_T("prop"), prop);
if (!found) {
throw std::runtime_error("Clauses must contain \"and\", \"or\", "
"or a comparison to make");
}
MojObject op;
found = clause.get(_T("op"), op);
if (!found) {
throw std::runtime_error("Clauses must specify a comparison operation "
"to perform");
}
MojObject val;
found = clause.get(_T("val"), val);
if (!found) {
throw std::runtime_error("Clauses must specify a value to compare "
"against");
}
MatchResult result = CheckProperty(prop, response, op, val, mode);
LOG_AM_DEBUG("Where Trigger: Clause %s %s",
MojoObjectJson(clause).c_str(), (result == Matched) ? "matched" :
"did not match");
return result;
}
bool MojoWhereMatcher::GetObjectValue(const MojObject& key,
const MojObject& response, MojObject& value) const
{
if (key.type() == MojObject::TypeString) {
MojString keyStr;
MojErr err = key.stringValue(keyStr);
if (err) {
throw std::runtime_error("Error attempting to retrieve key name "
"getting object value");
}
if (response.contains(keyStr)) {
return response.get(keyStr, value);
} else {
return false;
}
} else if (key.type() == MojObject::TypeArray) {
MojObject cur = response;
for (MojObject::ConstArrayIterator iter = key.arrayBegin();
iter != key.arrayEnd(); ++iter) {
const MojObject& keyObj = *iter;
if (keyObj.type() != MojObject::TypeString) {
throw std::runtime_error("Non-string found in property "
"specifiction array");
}
MojString keyStr;
MojErr err = keyObj.stringValue(keyStr);
if (err) {
throw std::runtime_error("Failed to access lookup key");
}
if (cur.contains(keyStr)) {
MojObject tmp;
if (!cur.get(keyStr, tmp)) {
return false;
} else {
cur = tmp;
}
} else {
return false;
}
}
value = cur;
return true;
} else {
throw std::runtime_error("Property specification must be the "
"property name or array of property names");
}
}
boost::shared_ptr<Requirement> TelephonyProxy::InstantiateRequirement(
boost::shared_ptr<Activity> activity, const std::string& name,
const MojObject& value)
{
LOG_TRACE("Entering function %s", __FUNCTION__);
LOG_DEBUG("Instantiating [Requirement %s] for [Activity %llu]",
name.c_str(), activity->GetId());
if (name == "telephony") {
if ((value.type() == MojObject::TypeBool) && value.boolValue()) {
boost::shared_ptr<ListedRequirement> req =
boost::make_shared<BasicCoreListedRequirement>(
activity, m_telephonyRequirementCore,
m_telephonyRequirementCore->IsMet());
m_telephonyRequirements.push_back(*req);
return req;
} else {
throw std::runtime_error("If a 'telephony' requirement is "
"specified, the only legal value is 'true'");
}
} else {
LOG_ERROR(MSGID_TIL_UNKNOWN_REQ, 3, PMLOGKS("MANAGER", GetName().c_str()),
PMLOGKS("REQ",name.c_str()),
PMLOGKFV("ACTIVITY_ID","%llu",activity->GetId()),
"does not know how to instantiate Requirement" );
throw std::runtime_error("Attempt to instantiate unknown requirement");
}
}
void MojoNewWhereMatcher::ValidateOp(const MojObject& op,
const MojObject& val) const
{
if (op.type() != MojObject::TypeString) {
throw std::runtime_error("Operation must be specified as a string "
"property");
}
MojString opStr;
MojErr err = op.stringValue(opStr);
if (err) {
throw std::runtime_error("Failed to convert operation to "
"string value");
}
if ((opStr != "<") && (opStr != "<=") && (opStr != "=") &&
(opStr != ">=") && (opStr != ">") && (opStr != "!=") &&
(opStr != "where")) {
throw std::runtime_error("Operation must be one of '<', '<=', "
"'=', '>=', '>', '!=', and 'where'");
}
if (opStr == "where") {
ValidateClauses(val);
}
}
void MojoWhereMatcher::ValidateKey(const MojObject& key) const
{
if (key.type() == MojObject::TypeArray) {
for (MojObject::ConstArrayIterator iter = key.arrayBegin();
iter != key.arrayEnd(); ++iter) {
const MojObject& keyObj = *iter;
if (keyObj.type() != MojObject::TypeString) {
throw std::runtime_error("Something other than a string "
"found in array of property names");
}
}
} else if (key.type() != MojObject::TypeString) {
throw std::runtime_error("Property keys must be specified as "
"a property name, or array of property names");
}
}
MojErr MojDbQuery::addClause(WhereMap& map, const MojChar* propName, CompOp op, const MojObject& val, MojDbCollationStrength coll)
{
MojAssert(propName);
// only allow valid ops
if (!(op >= OpEq && op <= OpSubString))
MojErrThrowMsg(MojErrDbInvalidQuery, _T("db: invalid query op"));
// only allow array values for = or % or %% ops
if (val.type() == MojObject::TypeArray && op != OpEq && op != OpPrefix && op != OpSubString)
MojErrThrowMsg(MojErrDbInvalidQuery, _T("db: query contains array value for non-eq op"));
// check to see if the prop is referenced in a prior clause
WhereMap::Iterator iter;
MojErr err = map.find(propName, iter);
MojErrCheck(err);
if (iter == map.end()) {
// create new clause
err = createClause(map, propName, op, val, coll);
MojErrCheck(err);
} else {
// add clause to previously referenced prop.
err = updateClause(iter.value(), op, val, coll);
MojErrCheck(err);
}
return MojErrNone;
}
MojErr MojDbPropExtractor::handleVal(const MojObject& val, KeySet& valsOut, MojSize idx) const
{
LOG_TRACE("Entering function %s", __FUNCTION__);
MojAssert(idx < m_prop.size());
MojErr err = MojErrNone;
if (idx == m_prop.size() - 1) {
// if we're at the end of the prop path, use this object as the value
if (m_tokenizer.get() && val.type() == MojObject::TypeString) {
MojString text;
err = val.stringValue(text);
MojErrCheck(err);
if (m_tokenizer.get()) {
err = m_tokenizer->tokenize(text, m_collator.get(), valsOut);
MojErrCheck(err);
}
} else {
MojDbKey key;
err = key.assign(val, m_collator.get());
MojErrCheck(err);
err = valsOut.put(key);
MojErrCheck(err);
}
} else {
// otherwise, keep recursing
err = valsImpl(val, valsOut, idx + 1);
MojErrCheck(err);
}
return MojErrNone;
}
MojErr MojDbPropExtractor::fromObjectImpl(const MojObject& obj, const MojDbPropExtractor& defaultConfig, const MojChar* locale)
{
LOG_TRACE("Entering function %s", __FUNCTION__);
// super
MojErr err = MojDbExtractor::fromObject(obj, locale);
MojErrCheck(err);
// default value
m_default = defaultConfig.m_default;
MojObject defaultVal;
if (obj.get(DefaultKey, defaultVal)) {
MojObject::Type type = defaultVal.type();
MojDbKey key;
if (type == MojObject::TypeArray) {
// if the value is an array, act on its elements rather than the array object itself
MojObject::ConstArrayIterator end = defaultVal.arrayEnd();
for (MojObject::ConstArrayIterator j = defaultVal.arrayBegin(); j != end; ++j) {
err = key.assign(*j);
MojErrCheck(err);
err = m_default.put(key);
MojErrCheck(err);
}
} else {
err = key.assign(defaultVal);
MojErrCheck(err);
err = m_default.put(key);
MojErrCheck(err);
}
}
// tokenizer
m_tokenizer = defaultConfig.m_tokenizer;
MojString tokenize;
bool found = false;
err = obj.get(TokenizeKey, tokenize, found);
MojErrCheck(err);
if (found) {
if (tokenize == AllKey || tokenize == DefaultKey) {
m_tokenizer.reset(new MojDbTextTokenizer);
MojAllocCheck(m_tokenizer.get());
err = m_tokenizer->init(locale);
MojErrCheck(err);
} else {
MojErrThrow(MojErrDbInvalidTokenization);
}
}
// collator
if (m_collation == MojDbCollationInvalid)
m_collation = defaultConfig.m_collation;
err = updateLocale(locale);
MojErrCheck(err);
// set prop
err = prop(m_name);
MojErrCheck(err);
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 BusClient::BusMethods::ScanRequest(MojServiceMessage* msg, MojObject& payload, ConfigurationMode confmode)
{
try {
MojErr err;
if (payload.type() != MojObject::TypeArray) {
MojErrThrowMsg(MojErrInternal, "invalid message format");
}
m_client.m_msg.reset(msg);
for (MojObject::ConstArrayIterator it = payload.arrayBegin(); it != payload.arrayEnd(); it++) {
const MojObject& request = *it;
MojString locationStr;
MojString typeStr;
MojString app;
BusClient::PackageType type;
BusClient::PackageLocation location;
err = request.getRequired("id", app);
MojErrCheck(err);
err = request.getRequired("type", typeStr);
MojErrCheck(err);
err = request.getRequired("location", locationStr);
MojErrCheck(err);
if (typeStr == "app") {
type = BusClient::Application;
} else if (typeStr == "service") {
type = BusClient::Service;
} else {
MojErrThrow(MojErrInvalidMsg);
}
if (locationStr == "system") {
location = BusClient::System;
} else if (locationStr == "third party") {
location = BusClient::ThirdParty;
} else {
MojErrThrow(MojErrInvalidMsg);
}
m_client.Scan(confmode, app, type, location);
}
m_client.RunNextConfigurator();
} catch (const std::exception& e) {
MojErrThrowMsg(MojErrInternal, "%s", e.what());
} catch (...) {
MojErrThrowMsg(MojErrInternal, "uncaught exception");
}
return MojErrNone;
}
bool MojoWhereMatcher::CheckClauses(const MojObject& clauses,
const MojObject& response) const
{
MojLogTrace(s_log);
if (clauses.type() == MojObject::TypeObject) {
return CheckClause(clauses, response);
} else if (clauses.type() == MojObject::TypeArray) {
for (MojObject::ConstArrayIterator iter = clauses.arrayBegin();
iter != clauses.arrayEnd(); ++iter) {
if (!CheckClause(*iter, response)) {
return false;
}
}
} else {
throw std::runtime_error("Clauses must consist of either a single "
"where clause or array of where clauses");
}
return true;
}
void MojoNewWhereMatcher::ValidateClauses(const MojObject& where) const
{
LOG_AM_TRACE("Entering function %s", __FUNCTION__);
LOG_AM_DEBUG("Validating trigger clauses");
if (where.type() == MojObject::TypeObject) {
ValidateClause(where);
} else if (where.type() == MojObject::TypeArray) {
for (MojObject::ConstArrayIterator iter = where.arrayBegin();
iter != where.arrayEnd(); ++iter) {
const MojObject& clause = *iter;
if (clause.type() != MojObject::TypeObject) {
throw std::runtime_error("where statement array must "
"consist of valid clauses");
} else {
ValidateClause(clause);
}
}
} else {
throw std::runtime_error("where statement should consist of a single "
"clause or array of valid clauses");
}
}
void MojoWhereMatcher::ValidateClauses(const MojObject& where) const
{
MojLogTrace(s_log);
MojLogInfo(s_log, _T("Validating trigger clauses"));
if (where.type() == MojObject::TypeObject) {
ValidateClause(where);
} else if (where.type() == MojObject::TypeArray) {
for (MojObject::ConstArrayIterator iter = where.arrayBegin();
iter != where.arrayEnd(); ++iter) {
const MojObject& clause = *iter;
if (clause.type() != MojObject::TypeObject) {
throw std::runtime_error("where statement array must "
"consist of valid clauses");
} else {
ValidateClause(clause);
}
}
} else {
throw std::runtime_error("where statement should consist of a single "
"clause or array of valid clauses");
}
}
MojoNewWhereMatcher::MatchResult MojoNewWhereMatcher::CheckClauses(
const MojObject& clauses, const MojObject& response, MatchMode mode) const
{
LOG_AM_TRACE("Entering function %s", __FUNCTION__);
if (clauses.type() == MojObject::TypeObject) {
return CheckClause(clauses, response, mode);
} else if (clauses.type() != MojObject::TypeArray) {
throw std::runtime_error("Multiple clauses must be specified as an "
"array of clauses");
}
LOG_AM_DEBUG("Checking clauses '%s' against response '%s' (%s)",
MojoObjectJson(clauses).c_str(), MojoObjectJson(response).c_str(),
(mode == AndMode) ? "and" : "or");
for (MojObject::ConstArrayIterator iter = clauses.arrayBegin();
iter != clauses.arrayEnd(); ++iter) {
MatchResult result = CheckClause(*iter, response, mode);
if (mode == AndMode) {
if (result != Matched) {
return NotMatched;
}
} else {
if (result == Matched) {
return Matched;
}
}
}
if (mode == AndMode) {
return Matched;
} else {
return NotMatched;
}
}
MojErr MojDbQueryPlan::pushVal(MojDbKeyBuilder& builder, const MojObject& val, MojDbTextCollator* collator)
{
MojErr err = MojErrNone;
MojDbKey key;
MojDbKeyBuilder::KeySet keys;
if (val.type() == MojObject::TypeArray) {
MojObject::ConstArrayIterator end = val.arrayEnd();
for (MojObject::ConstArrayIterator i = val.arrayBegin(); i != end; ++i) {
err = key.assign(*i, collator);
MojErrCheck(err);
err = keys.put(key);
MojErrCheck(err);
}
} else {
err = key.assign(val, collator);
MojErrCheck(err);
err = keys.put(key);
MojErrCheck(err);
}
err = builder.push(keys);
MojErrCheck(err);
return MojErrNone;
}
int ConnectionManagerProxy::ConfidenceToInt(const MojObject& confidenceObj) const
{
if (confidenceObj.type() != MojObject::TypeString) {
LOG_WARNING(MSGID_NON_STRING_TYPE_NW_CONFIDENCE, 0, "Network confidence must be specified as a string");
return ConnectionConfidenceUnknown;
}
MojString confidenceStr;
MojErr err = confidenceObj.stringValue(confidenceStr);
if (err != MojErrNone) {
LOG_WARNING(MSGID_GET_NW_CONFIDENCE_LEVEL_FAIL, 0, "Failed to retreive network confidence level as string");
return ConnectionConfidenceUnknown;
}
for (int i = 0; i < ConnectionConfidenceMax; ++i) {
if (confidenceStr == ConnectionConfidenceNames[i]) {
return i;
}
}
LOG_DEBUG("Unknown connection confidence string: \"%s\"", confidenceStr.data() );
return ConnectionConfidenceUnknown;
}
bool MojoWhereMatcher::CheckClause(const MojObject& clause,
const MojObject& response) const
{
MojLogTrace(s_log);
bool result;
if (clause.type() != MojObject::TypeObject) {
throw std::runtime_error("Clause must be an object with prop, op, "
"and val properties");
}
bool found;
MojObject prop;
found = clause.get(_T("prop"), prop);
if (!found) {
throw std::runtime_error("Property specifier not present in where "
"clause");
}
/* Value not present causes clause to be skipped.
* XXX allow missing behaviour to be specified? */
MojObject propValue;
found = GetObjectValue(prop, response, propValue);
if (found) {
MojObject clauseValue;
found = clause.get(_T("val"), clauseValue);
if (!found) {
throw std::runtime_error("Value to compare against not present in "
"where clause");
}
found = false;
MojString op;
MojErr err = clause.get(_T("op"), op, found);
if (err) {
throw std::runtime_error("Error retrieving operation to use for "
"where clause");
} else if (!found) {
throw std::runtime_error("operation to use for comparison not "
"present in where clause");
}
if (op == "<") {
result = (propValue < clauseValue);
} else if (op == "<=") {
result = (propValue <= clauseValue);
} else if (op == "=") {
result = (propValue == clauseValue);
} else if (op == "!=") {
result = (propValue != clauseValue);
} else if (op == ">=") {
result = (propValue >= clauseValue);
} else if (op == ">") {
result = (propValue > clauseValue);
} else {
throw std::runtime_error("Unknown comparison operator in where "
"clause");
}
} else {
result = false;
}
MojLogInfo(s_log, _T("Where Trigger: Clause %s %s"),
MojoObjectJson(clause).c_str(), result ? "matched" : "did not match");
return result;
}
MojErr MojObjectTest::typeTest()
{
MojObject obj;
MojObject obj2;
MojString str1;
MojString str2;
MojHashMap<MojObject, MojObject> map;
// null
MojTestAssert(obj.type() == MojObject::TypeUndefined);
MojTestAssert(obj.size() == 0);
MojTestAssert(obj.empty());
MojTestAssert(obj.boolValue() == false);
MojTestAssert(obj.intValue() == 0);
MojTestAssert(obj.decimalValue() == MojDecimal());
MojErr err = obj.stringValue(str1);
MojTestErrCheck(err);
MojTestAssert(str1 == _T("null"));
err = map.put(obj, obj);
MojTestErrCheck(err);
MojTestAssert(map.contains(obj));
MojTestAssert(obj == obj2);
MojTestAssert(obj.compare(obj2) == 0);
err = obj.coerce(MojObject::TypeNull);
MojTestErrCheck(err);
MojTestAssert(obj.type() == MojObject::TypeNull);
err = obj.coerce(MojObject::TypeString);
MojTestErrCheck(err);
MojTestAssert(obj == str1);
err = obj.coerce(MojObject::TypeBool);
MojTestErrCheck(err);
MojTestAssert(obj == true);
err = obj.coerce(MojObject::TypeInt);
MojTestErrCheck(err);
MojTestAssert(obj == 1);
err = obj.coerce(MojObject::TypeDecimal);
MojTestErrCheck(err);
MojTestAssert(obj.type() == MojObject::TypeDecimal && obj == MojDecimal(1, 0));
err = obj.coerce(MojObject::TypeObject);
MojTestErrCheck(err);
MojTestAssert(obj.type() == MojObject::TypeObject);
err = obj.coerce(MojObject::TypeArray);
MojTestErrCheck(err);
MojTestAssert(obj.type() == MojObject::TypeArray);
// object
err = obj.put(_T("hello"), 5);
MojTestErrCheck(err);
MojTestAssert(obj.type() == MojObject::TypeObject);
MojTestAssert(obj.size() == 1);
MojTestAssert(!obj.empty());
MojTestAssert(obj.boolValue() == true);
MojTestAssert(obj.intValue() == 0);
MojTestAssert(obj.decimalValue() == MojDecimal());
err = obj.stringValue(str1);
MojTestErrCheck(err);
MojTestAssert(str1 == _T("{\"hello\":5}"));
err = map.put(obj, obj);
MojTestErrCheck(err);
MojTestAssert(map.contains(obj));
obj.clear(MojObject::TypeObject);
MojTestAssert(obj.type() == MojObject::TypeObject);
MojTestAssert(obj.size() == 0);
MojTestAssert(obj.empty());
MojTestAssert(obj.boolValue() == false);
MojTestAssert(obj.intValue() == 0);
MojTestAssert(obj.decimalValue() == MojDecimal());
err = obj.stringValue(str1);
MojTestErrCheck(err);
MojTestAssert(str1 == _T("{}"));
// array
for (int i = 0; i < 1000; ++i) {
err = obj.push(i);
MojTestErrCheck(err);
}
MojTestAssert(obj.type() == MojObject::TypeArray);
MojTestAssert(obj.size() == 1000);
MojTestAssert(!obj.empty());
MojTestAssert(obj.boolValue() == true);
MojTestAssert(obj.intValue() == 0);
MojTestAssert(obj.decimalValue() == MojDecimal());
for (int i = 0; i < 1000; ++i) {
MojTestAssert(obj.at(i, obj2));
MojTestAssert(obj2 == i);
}
MojTestAssert(!obj.at(1000, obj2));
err = obj.setAt(1001, 1001);
MojTestErrCheck(err);
MojTestAssert(obj.size() == 1002);
MojTestAssert(obj.at(1000, obj2));
MojTestAssert(obj2.type() == MojObject::TypeUndefined);
obj.clear(MojObject::TypeArray);
MojTestAssert(obj.size() == 0);
MojTestAssert(obj.empty());
MojTestAssert(obj.boolValue() == false);
MojTestAssert(obj.intValue() == 0);
MojTestAssert(obj.decimalValue() == MojDecimal());
err = obj.stringValue(str1);
MojTestErrCheck(err);
MojTestAssert(str1 == _T("[]"));
err = map.put(obj, obj);
MojTestErrCheck(err);
MojTestAssert(map.contains(obj));
// string
err = str1.assign(_T("yo"));
MojTestErrCheck(err);
obj = str1;
MojTestAssert(obj.type() == MojObject::TypeString);
MojTestAssert(obj.size() == 0);
MojTestAssert(obj.empty());
MojTestAssert(obj.boolValue() == true);
MojTestAssert(obj.intValue() == 0);
MojTestAssert(obj.decimalValue() == MojDecimal());
err = obj.stringValue(str2);
MojTestErrCheck(err);
MojTestAssert(str1 == str2);
err = map.put(obj, obj);
MojTestErrCheck(err);
MojTestAssert(map.contains(obj));
obj.clear(MojObject::TypeString);
MojTestAssert(obj.boolValue() == false);
err = str1.assign(_T("12345"));
MojTestErrCheck(err);
obj = str1;
MojTestAssert(obj.intValue() == 12345);
MojTestAssert(obj.decimalValue() == MojDecimal(12345, 0));
err = str1.assign(_T("-67890"));
MojTestErrCheck(err);
obj = str1;
MojTestAssert(obj.intValue() == -67890);
MojTestAssert(obj.decimalValue() == MojDecimal(-67890, 0));
err = str1.assign(_T("12345000000000"));
MojTestErrCheck(err);
obj = str1;
MojTestAssert(obj.intValue() == 12345000000000LL);
err = str1.assign(_T("12345.6789"));
MojTestErrCheck(err);
obj = str1;
MojTestAssert(obj.intValue() == 12345);
MojTestAssert(obj.decimalValue() == MojDecimal(12345, 678900));
err = str1.assign(_T("1.0e3"));
MojTestErrCheck(err);
obj = str1;
MojTestAssert(obj.intValue() == 1);
MojTestAssert(obj.decimalValue() == MojDecimal(1000, 0));
err = str1.assign(_T("45hello"));
MojTestErrCheck(err);
obj = str1;
MojTestAssert(obj.intValue() == 45);
MojTestAssert(obj.decimalValue() == MojDecimal(45, 0));
// bool
obj = true;
MojTestAssert(obj.type() == MojObject::TypeBool);
MojTestAssert(obj.size() == 0);
MojTestAssert(obj.empty());
MojTestAssert(obj.boolValue() == true);
MojTestAssert(obj.intValue() == 1);
MojTestAssert(obj.decimalValue() == MojDecimal(1, 0));
err = obj.stringValue(str1);
MojTestErrCheck(err);
MojTestAssert(str1 == _T("true"));
obj.clear(MojObject::TypeBool);
MojTestAssert(obj.boolValue() == false);
MojTestAssert(obj.intValue() == 0);
MojTestAssert(obj.decimalValue() == MojDecimal());
err = obj.stringValue(str1);
MojTestErrCheck(err);
MojTestAssert(str1 == _T("false"));
err = map.put(obj, obj);
MojTestErrCheck(err);
MojTestAssert(map.contains(obj));
// MojDecimal
obj = MojDecimal(3, 140000);
MojTestAssert(obj.type() == MojObject::TypeDecimal);
MojTestAssert(obj.size() == 0);
MojTestAssert(obj.empty());
MojTestAssert(obj.boolValue() == true);
MojTestAssert(obj.intValue() == 3);
MojTestAssert(obj.decimalValue() == MojDecimal(3.14));
err = obj.stringValue(str1);
MojTestErrCheck(err);
MojTestAssert(str1 == _T("3.14"));
obj.clear(MojObject::TypeDecimal);
MojTestAssert(obj.boolValue() == false);
MojTestAssert(obj.intValue() == 0);
MojTestAssert(obj.decimalValue() == MojDecimal());
err = obj.stringValue(str1);
MojTestErrCheck(err);
MojTestAssert(str1 == _T("0.0"));
err = map.put(obj, obj);
MojTestErrCheck(err);
MojTestAssert(map.contains(obj));
// MojDecimal
obj = -987654321;
MojTestAssert(obj.type() == MojObject::TypeInt);
MojTestAssert(obj.size() == 0);
MojTestAssert(obj.empty());
MojTestAssert(obj.boolValue() == true);
MojTestAssert(obj.intValue() == -987654321);
MojTestAssert(obj.decimalValue() == MojDecimal(-987654321, 0));
err = obj.stringValue(str1);
MojTestErrCheck(err);
MojTestAssert(str1 == _T("-987654321"));
obj.clear(MojObject::TypeInt);
MojTestAssert(obj.boolValue() == false);
MojTestAssert(obj.intValue() == 0);
MojTestAssert(obj.decimalValue() == MojDecimal());
err = obj.stringValue(str1);
MojTestErrCheck(err);
MojTestAssert(str1 == _T("0"));
err = map.put(obj, obj);
MojTestErrCheck(err);
MojTestAssert(map.contains(obj));
return MojErrNone;
}
MojErr BusClient::BusMethods::Unconfigure(MojServiceMessage *msg, MojObject &payload)
{
MojLogTrace(m_log);
if (WorkEnqueued((Callback) &BusMethods::Unconfigure, msg, payload))
return MojErrNone;
try {
MojErr err;
if (payload.type() != MojObject::TypeArray) {
MojErrThrowMsg(MojErrInternal, "invalid message format");
}
m_client.m_msg.reset(msg);
for (MojObject::ConstArrayIterator it = payload.arrayBegin(); it != payload.arrayEnd(); it++) {
const MojObject& request = *it;
MojString locationStr;
MojString typeStr;
MojObject typesArray;
MojString app;
BusClient::PackageType type;
BusClient::PackageLocation location;
BusClient::ScanTypes types;
err = request.getRequired("id", app);
MojErrCheck(err);
err = request.getRequired("type", typeStr);
MojErrCheck(err);
if (!request.get("types", typesArray)) {
types = BusClient::ACTIVITIES | BusClient::FILECACHE | BusClient::DBKINDS | BusClient::DBPERMISSIONS;
} else {
err = getTypes(typesArray, types);
MojErrCheck(err);
}
err = request.getRequired("location", locationStr);
MojErrCheck(err);
if (typeStr == "app") {
type = BusClient::Application;
} else if (typeStr == "service") {
type = BusClient::Service;
} else {
MojErrThrow(MojErrInvalidMsg);
}
if (locationStr == "system") {
location = BusClient::System;
} else if (locationStr == "third party") {
location = BusClient::ThirdParty;
} else {
MojErrThrow(MojErrInvalidMsg);
}
m_client.Unconfigure(app, type, location, types);
}
m_client.RunNextConfigurator();
} catch (const std::exception& e) {
MojErrThrowMsg(MojErrInternal, "%s", e.what());
} catch (...) {
MojErrThrowMsg(MojErrInternal, "uncaught exception");
}
return MojErrNone;
}