Source code
Revision control
Copy as Markdown
Other Tools
/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
/* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this
#include "nsIAbCard.h"
#include "nsAbDirectoryQuery.h"
#include "nsAbDirectoryQueryProxy.h"
#include "nsAbBooleanExpression.h"
#include "nsComponentManagerUtils.h"
#include "nsString.h"
#include "nsUnicharUtils.h"
#include "nsIAbDirSearchListener.h"
#include "nsISimpleEnumerator.h"
#include "nsMsgUtils.h"
#include "nsQueryObject.h"
NS_IMPL_ISUPPORTS(nsAbDirectoryQuerySimpleBooleanExpression,
nsIAbBooleanExpression)
nsAbDirectoryQuerySimpleBooleanExpression::
nsAbDirectoryQuerySimpleBooleanExpression()
: mOperation(nsIAbBooleanOperationTypes::AND) {}
nsAbDirectoryQuerySimpleBooleanExpression::
~nsAbDirectoryQuerySimpleBooleanExpression() {}
/* attribute nsAbBooleanOperationType operation; */
NS_IMETHODIMP nsAbDirectoryQuerySimpleBooleanExpression::GetOperation(
nsAbBooleanOperationType* aOperation) {
if (!aOperation) return NS_ERROR_NULL_POINTER;
*aOperation = mOperation;
return NS_OK;
}
NS_IMETHODIMP nsAbDirectoryQuerySimpleBooleanExpression::SetOperation(
nsAbBooleanOperationType aOperation) {
if (aOperation != nsIAbBooleanOperationTypes::AND &&
aOperation != nsIAbBooleanOperationTypes::OR)
return NS_ERROR_FAILURE;
mOperation = aOperation;
return NS_OK;
}
/* attribute Array<nsISupports> expressions; */
NS_IMETHODIMP nsAbDirectoryQuerySimpleBooleanExpression::GetExpressions(
nsTArray<RefPtr<nsISupports>>& aExpressions) {
aExpressions = mExpressions.Clone();
return NS_OK;
}
NS_IMETHODIMP nsAbDirectoryQuerySimpleBooleanExpression::SetExpressions(
const nsTArray<RefPtr<nsISupports>>& aExpressions) {
// Ensure all the items are of the right type.
nsresult rv;
nsCOMPtr<nsIAbBooleanConditionString> queryExpression;
for (auto expression : aExpressions) {
queryExpression = do_QueryInterface(expression, &rv);
if (NS_FAILED(rv)) return NS_ERROR_ILLEGAL_VALUE;
}
// Values ok, so we can just save and return.
mExpressions = aExpressions.Clone();
return NS_OK;
}
NS_IMPL_ISUPPORTS(nsAbDirectoryQueryArguments, nsIAbDirectoryQueryArguments)
nsAbDirectoryQueryArguments::nsAbDirectoryQueryArguments()
: mQuerySubDirectories(true) {}
nsAbDirectoryQueryArguments::~nsAbDirectoryQueryArguments() {}
/* attribute nsISupports matchItems; */
NS_IMETHODIMP nsAbDirectoryQueryArguments::GetExpression(
nsISupports** aExpression) {
if (!aExpression) return NS_ERROR_NULL_POINTER;
NS_IF_ADDREF(*aExpression = mExpression);
return NS_OK;
}
NS_IMETHODIMP nsAbDirectoryQueryArguments::SetExpression(
nsISupports* aExpression) {
mExpression = aExpression;
return NS_OK;
}
/* attribute boolean querySubDirectories; */
NS_IMETHODIMP nsAbDirectoryQueryArguments::GetQuerySubDirectories(
bool* aQuerySubDirectories) {
NS_ENSURE_ARG_POINTER(aQuerySubDirectories);
*aQuerySubDirectories = mQuerySubDirectories;
return NS_OK;
}
NS_IMETHODIMP nsAbDirectoryQueryArguments::SetQuerySubDirectories(
bool aQuerySubDirectories) {
mQuerySubDirectories = aQuerySubDirectories;
return NS_OK;
}
NS_IMETHODIMP nsAbDirectoryQueryArguments::GetTypeSpecificArg(
nsISupports** aArg) {
NS_ENSURE_ARG_POINTER(aArg);
NS_IF_ADDREF(*aArg = mTypeSpecificArg);
return NS_OK;
}
NS_IMETHODIMP nsAbDirectoryQueryArguments::SetTypeSpecificArg(
nsISupports* aArg) {
mTypeSpecificArg = aArg;
return NS_OK;
}
NS_IMETHODIMP nsAbDirectoryQueryArguments::GetFilter(nsACString& aFilter) {
aFilter.Assign(mFilter);
return NS_OK;
}
NS_IMETHODIMP nsAbDirectoryQueryArguments::SetFilter(
const nsACString& aFilter) {
mFilter.Assign(aFilter);
return NS_OK;
}
NS_IMPL_ISUPPORTS(nsAbDirectoryQueryPropertyValue,
nsIAbDirectoryQueryPropertyValue)
nsAbDirectoryQueryPropertyValue::nsAbDirectoryQueryPropertyValue() {}
nsAbDirectoryQueryPropertyValue::nsAbDirectoryQueryPropertyValue(
const char* aName, const char16_t* aValue) {
mName = aName;
mValue = aValue;
}
nsAbDirectoryQueryPropertyValue::nsAbDirectoryQueryPropertyValue(
const char* aName, nsISupports* aValueISupports) {
mName = aName;
mValueISupports = aValueISupports;
}
nsAbDirectoryQueryPropertyValue::~nsAbDirectoryQueryPropertyValue() {}
/* read only attribute string name; */
NS_IMETHODIMP nsAbDirectoryQueryPropertyValue::GetName(char** aName) {
*aName = mName.IsEmpty() ? 0 : ToNewCString(mName);
return NS_OK;
}
/* read only attribute wstring value; */
NS_IMETHODIMP nsAbDirectoryQueryPropertyValue::GetValue(char16_t** aValue) {
*aValue = ToNewUnicode(mValue);
if (!(*aValue))
return NS_ERROR_OUT_OF_MEMORY;
else
return NS_OK;
}
/* readonly attribute nsISupports valueISupports; */
NS_IMETHODIMP nsAbDirectoryQueryPropertyValue::GetValueISupports(
nsISupports** aValueISupports) {
if (!mValueISupports) return NS_ERROR_NULL_POINTER;
NS_IF_ADDREF(*aValueISupports = mValueISupports);
return NS_OK;
}
/* Implementation file */
NS_IMPL_ISUPPORTS(nsAbDirectoryQuery, nsIAbDirectoryQuery)
nsAbDirectoryQuery::nsAbDirectoryQuery() {}
nsAbDirectoryQuery::~nsAbDirectoryQuery() {}
NS_IMETHODIMP nsAbDirectoryQuery::DoQuery(
nsIAbDirectory* aDirectory, nsIAbDirectoryQueryArguments* arguments,
nsIAbDirSearchListener* listener, int32_t resultLimit, int32_t timeOut,
int32_t* _retval) {
NS_ENSURE_ARG_POINTER(aDirectory);
nsCOMPtr<nsISupports> supportsExpression;
nsresult rv = arguments->GetExpression(getter_AddRefs(supportsExpression));
NS_ENSURE_SUCCESS(rv, rv);
nsCOMPtr<nsIAbBooleanExpression> expression(
do_QueryInterface(supportsExpression, &rv));
NS_ENSURE_SUCCESS(rv, rv);
bool doSubDirectories;
rv = arguments->GetQuerySubDirectories(&doSubDirectories);
NS_ENSURE_SUCCESS(rv, rv);
rv = query(aDirectory, expression, listener, doSubDirectories, &resultLimit);
NS_ENSURE_SUCCESS(rv, rv);
rv = listener->OnSearchFinished(rv, true, nullptr, ""_ns);
*_retval = 0;
return rv;
}
/* void stopQuery (in long contextID); */
NS_IMETHODIMP nsAbDirectoryQuery::StopQuery(int32_t contextID) { return NS_OK; }
nsresult nsAbDirectoryQuery::query(nsIAbDirectory* directory,
nsIAbBooleanExpression* expression,
nsIAbDirSearchListener* listener,
bool doSubDirectories,
int32_t* resultLimit) {
if (*resultLimit == 0) return NS_OK;
nsresult rv = queryCards(directory, expression, listener, resultLimit);
NS_ENSURE_SUCCESS(rv, rv);
if (*resultLimit != 0 && doSubDirectories) {
rv = queryChildren(directory, expression, listener, doSubDirectories,
resultLimit);
NS_ENSURE_SUCCESS(rv, rv);
}
return rv;
}
nsresult nsAbDirectoryQuery::queryChildren(nsIAbDirectory* directory,
nsIAbBooleanExpression* expression,
nsIAbDirSearchListener* listener,
bool doSubDirectories,
int32_t* resultLimit) {
nsTArray<RefPtr<nsIAbDirectory>> subDirectories;
nsresult rv = directory->GetChildNodes(subDirectories);
NS_ENSURE_SUCCESS(rv, rv);
for (nsIAbDirectory* subDirectory : subDirectories) {
rv = query(subDirectory, expression, listener, doSubDirectories,
resultLimit);
NS_ENSURE_SUCCESS(rv, rv);
}
return NS_OK;
}
nsresult nsAbDirectoryQuery::queryCards(nsIAbDirectory* directory,
nsIAbBooleanExpression* expression,
nsIAbDirSearchListener* listener,
int32_t* resultLimit) {
nsTArray<RefPtr<nsIAbCard>> cards;
nsresult rv = directory->GetChildCards(cards);
if (rv == NS_ERROR_NOT_IMPLEMENTED) {
return NS_OK;
}
NS_ENSURE_SUCCESS(rv, rv);
for (nsIAbCard* card : cards) {
rv = matchCard(card, expression, listener, resultLimit);
NS_ENSURE_SUCCESS(rv, rv);
if (*resultLimit == 0) return NS_OK;
}
return NS_OK;
}
nsresult nsAbDirectoryQuery::matchCard(nsIAbCard* card,
nsIAbBooleanExpression* expression,
nsIAbDirSearchListener* listener,
int32_t* resultLimit) {
bool matchFound = false;
nsresult rv = matchCardExpression(card, expression, &matchFound);
NS_ENSURE_SUCCESS(rv, rv);
if (matchFound) {
(*resultLimit)--;
rv = listener->OnSearchFoundCard(card);
NS_ENSURE_SUCCESS(rv, rv);
}
return rv;
}
nsresult nsAbDirectoryQuery::matchCardExpression(
nsIAbCard* card, nsIAbBooleanExpression* expression, bool* result) {
nsAbBooleanOperationType operation;
nsresult rv = expression->GetOperation(&operation);
NS_ENSURE_SUCCESS(rv, rv);
nsTArray<RefPtr<nsISupports>> childExpressions;
rv = expression->GetExpressions(childExpressions);
NS_ENSURE_SUCCESS(rv, rv);
uint32_t count = childExpressions.Length();
NS_ENSURE_SUCCESS(rv, rv);
if (operation == nsIAbBooleanOperationTypes::NOT && count > 1)
return NS_ERROR_FAILURE;
bool value = *result = false;
nsCOMPtr<nsIAbBooleanConditionString> childCondition;
nsCOMPtr<nsIAbBooleanExpression> childExpression;
for (uint32_t i = 0; i < count; i++) {
childCondition = do_QueryObject(childExpressions[i], &rv);
if (NS_SUCCEEDED(rv)) {
rv = matchCardCondition(card, childCondition, &value);
NS_ENSURE_SUCCESS(rv, rv);
} else {
childExpression = do_QueryObject(childExpressions[i], &rv);
if (NS_SUCCEEDED(rv)) {
rv = matchCardExpression(card, childExpression, &value);
NS_ENSURE_SUCCESS(rv, rv);
} else
return NS_ERROR_FAILURE;
}
if (operation == nsIAbBooleanOperationTypes::OR && value)
break;
else if (operation == nsIAbBooleanOperationTypes::AND && !value)
break;
else if (operation == nsIAbBooleanOperationTypes::NOT)
value = !value;
}
*result = value;
return NS_OK;
}
nsresult nsAbDirectoryQuery::matchCardCondition(
nsIAbCard* card, nsIAbBooleanConditionString* condition, bool* matchFound) {
nsAbBooleanConditionType conditionType;
nsresult rv = condition->GetCondition(&conditionType);
NS_ENSURE_SUCCESS(rv, rv);
nsCString name;
rv = condition->GetName(getter_Copies(name));
NS_ENSURE_SUCCESS(rv, rv);
if (name.Equals("card:nsIAbCard")) {
*matchFound = (conditionType == nsIAbBooleanConditionTypes::Exists);
return NS_OK;
}
nsString matchValue;
rv = condition->GetValue(getter_Copies(matchValue));
NS_ENSURE_SUCCESS(rv, rv);
if (name.EqualsLiteral("IsMailList")) {
bool isMailList;
rv = card->GetIsMailList(&isMailList);
NS_ENSURE_SUCCESS(rv, rv);
// Only equals is supported.
if (conditionType != nsIAbBooleanConditionTypes::Is)
return NS_ERROR_FAILURE;
*matchFound = isMailList ? matchValue.EqualsLiteral("TRUE")
: matchValue.EqualsLiteral("FALSE");
return NS_OK;
}
nsString value;
(void)card->GetPropertyAsAString(name.get(), value);
if (value.IsEmpty()) {
*matchFound = (conditionType == nsIAbBooleanConditionTypes::DoesNotExist)
? true
: false;
return NS_OK;
}
/* TODO
* What about allowing choice between case insensitive
* and case sensitive comparisons?
*
*/
switch (conditionType) {
case nsIAbBooleanConditionTypes::Exists:
*matchFound = true;
break;
case nsIAbBooleanConditionTypes::Contains:
*matchFound = CaseInsensitiveFindInReadable(matchValue, value);
break;
case nsIAbBooleanConditionTypes::DoesNotContain:
*matchFound = !CaseInsensitiveFindInReadable(matchValue, value);
break;
case nsIAbBooleanConditionTypes::Is:
*matchFound = value.Equals(matchValue, nsCaseInsensitiveStringComparator);
break;
case nsIAbBooleanConditionTypes::IsNot:
*matchFound =
!value.Equals(matchValue, nsCaseInsensitiveStringComparator);
break;
case nsIAbBooleanConditionTypes::BeginsWith:
*matchFound = StringBeginsWith(value, matchValue,
nsCaseInsensitiveStringComparator);
break;
case nsIAbBooleanConditionTypes::LessThan:
*matchFound =
Compare(value, matchValue, nsCaseInsensitiveStringComparator) < 0;
break;
case nsIAbBooleanConditionTypes::GreaterThan:
*matchFound =
Compare(value, matchValue, nsCaseInsensitiveStringComparator) > 0;
break;
case nsIAbBooleanConditionTypes::EndsWith:
*matchFound =
StringEndsWith(value, matchValue, nsCaseInsensitiveStringComparator);
break;
case nsIAbBooleanConditionTypes::SoundsLike:
case nsIAbBooleanConditionTypes::RegExp:
*matchFound = false;
break;
default:
*matchFound = false;
}
return rv;
}