>> >> /**
>> >> * List of defined match items types
>> >> *
>> >> */
>> >> const long matchItemsOneOrMore = 0;
>> >> const long matchItemsAll = 1;
>> >>
>> >
>> >Would it be worthwhile to design the interfaces to support boolean
>> >logic (and, or, not, precedence), to allow for future expansion?
>
>I'm still curious to hear any thoughts you might have on the above
>question.
>
Still thinking on it!
Example:
(name == "X" && nickname == "Y") ||
(email 'contains' "ZSxsxZ" || !(fax="123"))
Note sure how to do it beyond creating interfaces to
cater for statements and operators i.e. defining
a binary tree representing the statement where the
nodes are operations. Not sure i am using the correct
terminology but you see these types of things
when looking at compiler books, if one feels
so inclined, when referring to parsing statements.
Hmm... i see what you are saying though.
How about a statement interface (which is just
a type with no methods) and a simple statement
interface which inherits from this.
interface Statement : nsISupports
{
};
interface SimpleAndOrStatement: Statement
{
attribute nsISupportsArray matchItems;
attribute long matchItemsType;
};
The nsIAbDirectoryQueryArguments will then
contain a statement attribute.
Further inheritance from statement could then
define unary & binary boolean operations which
contain statement attributes. A leaf statement
will be a match item.
>> Attached is a version with support for nsISupportsArray
>> and arrays. Additionally added an nsISupports attribute
>> to the QueryPropertyValue interface if a property
>> is associated with an interface (e.g. nsIAbCard).
>
>Cool; it would be interesting to hear any comments on these from
>Candice or Ducarroz...
>
Attached is a synchronous implementation of the existing
query interfaces which does a linear search over
the address books, just like auto completion.
(Sorry no comments i hammered it out yesterday
real fast).
The class nsAbDirectoryQueryAutoComplete performs
a query using the same parameters as that for
the auto complete, see the method:
nsAbDirectoryQueryAutoComplete::Start
The example uses a value of 'paul' for all the
match items. 3 query results are returned
(see the moz.gif image for the list of cards
and the moz.txt file for the output from
the query listener).
The only thing which is missing is case insensitive
matching, thus i think an extra boolean attribute
is required on the match item interface.
Paul.
| ? + ? = To question
----------------\
Paul Sandoz
x19219
+353-1-8199219
moz.gif
IN nsAbDirectoryQueryAutoComplete::OnQueryItem
Type: queryResultMatch
Properties for match: 3
Property 0: PrimaryEmail
Value [string]: p@sun
Property 1: card:nsIAbCard
Value [Card]: 0xbfffd260
Property 2: card:URI
Value [string]: abmdbcard://abook.mab/Card58
OUT nsAbDirectoryQueryAutoComplete::OnQueryItem
IN nsAbDirectoryQueryAutoComplete::OnQueryItem
Type: queryResultMatch
Properties for match: 3
Property 0: PrimaryEmail
Value [string]: [EMAIL PROTECTED]
Property 1: card:nsIAbCard
Value [Card]: 0xbfffd260
Property 2: card:URI
Value [string]: abmdbcard://abook.mab/Card61
OUT nsAbDirectoryQueryAutoComplete::OnQueryItem
IN nsAbDirectoryQueryAutoComplete::OnQueryItem
Type: queryResultMatch
Properties for match: 3
Property 0: PrimaryEmail
Value [string]: [EMAIL PROTECTED]
Property 1: card:nsIAbCard
Value [Card]: 0xbfffd260
Property 2: card:URI
Value [string]: abmdbcard://abook.mab/Card62
OUT nsAbDirectoryQueryAutoComplete::OnQueryItem
IN nsAbDirectoryQueryAutoComplete::OnQueryItem
Type: queryResultComplete
OUT nsAbDirectoryQueryAutoComplete::OnQueryItem
#ifndef nsAbDirectoryQuery_h__
#define nsAbDirectoryQuery_h__
#include "nsIAbDirectoryQuery.h"
#include "nsCOMPtr.h"
#include "nsString.h"
class nsAbDirectoryQueryProperty : public nsIAbDirectoryQueryProperty
{
public:
NS_DECL_ISUPPORTS
NS_DECL_NSIABDIRECTORYQUERYPROPERTY
nsAbDirectoryQueryProperty();
virtual ~nsAbDirectoryQueryProperty();
static NS_METHOD Create(nsISupports *aOuter, REFNSIID aIID, void **aResult);
protected:
nsCString mName;
};
class nsAbDirectoryQueryPropertyValue : public nsIAbDirectoryQueryPropertyValue
{
public:
NS_DECL_ISUPPORTS
NS_DECL_NSIABDIRECTORYQUERYPROPERTY
NS_DECL_NSIABDIRECTORYQUERYPROPERTYVALUE
nsAbDirectoryQueryPropertyValue();
nsAbDirectoryQueryPropertyValue(nsCString& aName,
nsString& aValue);
nsAbDirectoryQueryPropertyValue(nsCString& aName,
nsISupports* aValueISupports);
virtual ~nsAbDirectoryQueryPropertyValue();
protected:
nsCString mName;
nsString mValue;
nsCOMPtr<nsISupports> mValueISupports;
};
class nsAbDirectoryQueryMatchItem : public nsIAbDirectoryQueryMatchItem
{
public:
NS_DECL_ISUPPORTS
NS_DECL_NSIABDIRECTORYQUERYPROPERTY
NS_DECL_NSIABDIRECTORYQUERYMATCHITEM
nsAbDirectoryQueryMatchItem();
virtual ~nsAbDirectoryQueryMatchItem();
static NS_METHOD Create(nsISupports *aOuter, REFNSIID aIID, void **aResult);
protected:
nsCString mName;
PRInt32 mMatchType;
nsString mMatchValue;
};
class nsAbDirectoryQueryArguments : public nsIAbDirectoryQueryArguments
{
public:
NS_DECL_ISUPPORTS
NS_DECL_NSIABDIRECTORYQUERYARGUMENTS
nsAbDirectoryQueryArguments();
virtual ~nsAbDirectoryQueryArguments();
static NS_METHOD Create(nsISupports *aOuter, REFNSIID aIID, void **aResult);
protected:
nsCOMPtr<nsISupportsArray> mMatchItems;
PRInt32 mMatchItemsType;
PRBool mQuerySubDirectories;
nsCOMPtr<nsISupportsArray> mReturnProperties;
};
class nsAbDirectoryQueryResult : public nsIAbDirectoryQueryResult
{
public:
NS_DECL_ISUPPORTS
NS_DECL_NSIABDIRECTORYQUERYRESULT
nsAbDirectoryQueryResult();
nsAbDirectoryQueryResult(PRInt32 aContextID,
nsIAbDirectoryQueryArguments* aContextArgs,
PRInt32 aType,
nsCOMPtr<nsISupportsArray> aResult);
virtual ~nsAbDirectoryQueryResult();
protected:
PRInt32 mContextID;
nsCOMPtr<nsIAbDirectoryQueryArguments> mContextArgs;
PRInt32 mType;
nsCOMPtr<nsISupportsArray> mResult;
};
#include "nsIAbDirectory.h"
class nsAbDirectoryQuery : public nsIAbDirectoryQuery
{
public:
NS_DECL_ISUPPORTS
NS_DECL_NSIABDIRECTORYQUERY
nsAbDirectoryQuery(nsIAbDirectory* aDirectory);
virtual ~nsAbDirectoryQuery();
protected:
nsresult query (nsIAbDirectory* directory,
nsIAbDirectoryQueryArguments* arguments,
nsIAbDirectoryQueryResultListener* listener,
PRInt32* resultLimit);
nsresult queryChildren (nsIAbDirectory* directory,
nsIAbDirectoryQueryArguments* arguments,
nsIAbDirectoryQueryResultListener* listener,
PRInt32* resultLimit);
nsresult queryCards (nsIAbDirectory* directory,
nsIAbDirectoryQueryArguments* arguments,
nsIAbDirectoryQueryResultListener* listener,
PRInt32* resultLimit);
nsresult matchCard (nsIAbCard* card,
nsIAbDirectoryQueryArguments* arguments,
nsIAbDirectoryQueryResultListener* listener,
PRInt32* resultLimit);
nsresult matchCardMatchItem (nsIAbCard* card,
nsIAbDirectoryQueryMatchItem* matchItem,
PRBool* matchFound);
nsresult queryMatch (nsIAbCard* card,
nsIAbDirectoryQueryArguments* arguments,
nsIAbDirectoryQueryResultListener* listener);
nsresult queryFinished (nsIAbDirectoryQueryArguments* arguments,
nsIAbDirectoryQueryResultListener* listener);
nsresult queryError (nsIAbDirectoryQueryArguments* arguments,
nsIAbDirectoryQueryResultListener* listener);
protected:
nsCOMPtr<nsIAbDirectory> mDirectory;
};
class nsAbDirectoryQueryAutoComplete : public nsIAbDirectoryQueryResultListener
{
public:
NS_DECL_ISUPPORTS
NS_DECL_NSIABDIRECTORYQUERYRESULTLISTENER
nsAbDirectoryQueryAutoComplete();
virtual ~nsAbDirectoryQueryAutoComplete();
nsresult Start (nsIAbDirectory* directory);
};
#endif
#include "nsXPIDLString.h"
#include "nsIRDFResource.h"
#include "nsAbDirectoryQuery.h"
NS_IMPL_ISUPPORTS1(nsAbDirectoryQueryProperty, nsIAbDirectoryQueryProperty)
nsAbDirectoryQueryProperty::nsAbDirectoryQueryProperty()
{
NS_INIT_ISUPPORTS();
}
nsAbDirectoryQueryProperty::~nsAbDirectoryQueryProperty()
{
}
/* attribute string name; */
NS_IMETHODIMP nsAbDirectoryQueryProperty::GetName(char* *aName)
{
const char* value = mName.get ();
if (!value)
*aName = 0;
else
*aName = PL_strdup (mName.get ());
return NS_OK;
}
NS_IMETHODIMP nsAbDirectoryQueryProperty::SetName(const char* aName)
{
if (aName)
mName = aName;
return NS_OK;
}
NS_METHOD nsAbDirectoryQueryProperty::Create(nsISupports* aOuter, REFNSIID aIID, void*
*aResult)
{
if (aOuter)
return NS_ERROR_NO_AGGREGATION;
nsAbDirectoryQueryProperty* it = new nsAbDirectoryQueryProperty();
if (it == NULL)
return NS_ERROR_OUT_OF_MEMORY;
NS_ADDREF(it);
nsresult rv = it->QueryInterface(aIID, aResult);
NS_RELEASE(it);
return rv;
}
NS_COM nsresult NS_NewIAbDirectoryQueryProperty(nsIAbDirectoryQueryProperty**
aInstancePtrResult)
{
nsresult rv;
rv = nsAbDirectoryQueryProperty::Create(NULL,
NS_GET_IID(nsIAbDirectoryQueryProperty),
(void**)aInstancePtrResult);
return rv;
}
NS_IMPL_ISUPPORTS2(nsAbDirectoryQueryPropertyValue, nsIAbDirectoryQueryPropertyValue,
nsIAbDirectoryQueryProperty)
nsAbDirectoryQueryPropertyValue::nsAbDirectoryQueryPropertyValue()
{
NS_INIT_ISUPPORTS();
}
nsAbDirectoryQueryPropertyValue::nsAbDirectoryQueryPropertyValue(nsCString& aName,
nsString& aValue)
{
NS_INIT_ISUPPORTS();
mName = aName;
mValue = aValue;
}
nsAbDirectoryQueryPropertyValue::nsAbDirectoryQueryPropertyValue(nsCString& aName,
nsISupports* aValueISupports)
{
NS_INIT_ISUPPORTS();
mName = aName;
mValueISupports = aValueISupports;
}
nsAbDirectoryQueryPropertyValue::~nsAbDirectoryQueryPropertyValue()
{
}
/* attribute string name; */
NS_IMETHODIMP nsAbDirectoryQueryPropertyValue::GetName(char* *aName)
{
const char* value = mName.get ();
if (!value)
*aName = 0;
else
*aName = PL_strdup (mName.get ());
return NS_OK;
}
NS_IMETHODIMP nsAbDirectoryQueryPropertyValue::SetName(const char* aName)
{
if (aName)
mName = aName;
return NS_OK;
}
/* attribute wstring value; */
NS_IMETHODIMP nsAbDirectoryQueryPropertyValue::GetValue(PRUnichar* *aValue)
{
*aValue = mValue.ToNewUnicode();
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;
*aValueISupports = mValueISupports;
NS_ADDREF(*aValueISupports);
return NS_OK;
}
NS_IMPL_ISUPPORTS2(nsAbDirectoryQueryMatchItem, nsIAbDirectoryQueryMatchItem,
nsIAbDirectoryQueryProperty)
nsAbDirectoryQueryMatchItem::nsAbDirectoryQueryMatchItem() :
mMatchType (matchExists)
{
NS_INIT_ISUPPORTS();
}
nsAbDirectoryQueryMatchItem::~nsAbDirectoryQueryMatchItem()
{
}
/* attribute string name; */
NS_IMETHODIMP nsAbDirectoryQueryMatchItem::GetName(char* *aName)
{
const char* value = mName.get ();
if (!value)
*aName = 0;
else
*aName = PL_strdup (mName.get ());
return NS_OK;
}
NS_IMETHODIMP nsAbDirectoryQueryMatchItem::SetName(const char* aName)
{
if (aName)
mName = aName;
return NS_OK;
}
/* attribute long matchType; */
NS_IMETHODIMP nsAbDirectoryQueryMatchItem::GetMatchType(PRInt32 *aMatchType)
{
*aMatchType = mMatchType;
return NS_OK;
}
NS_IMETHODIMP nsAbDirectoryQueryMatchItem::SetMatchType(PRInt32 aMatchType)
{
mMatchType = aMatchType;
return NS_OK;
}
/* attribute wstring matchValue; */
NS_IMETHODIMP nsAbDirectoryQueryMatchItem::GetMatchValue(PRUnichar* *aMatchValue)
{
*aMatchValue = mMatchValue.ToNewUnicode();
if (!(*aMatchValue))
return NS_ERROR_OUT_OF_MEMORY;
else
return NS_OK;
}
NS_IMETHODIMP nsAbDirectoryQueryMatchItem::SetMatchValue(const PRUnichar* aMatchValue)
{
if (aMatchValue)
mMatchValue = aMatchValue;
return NS_OK;
}
NS_METHOD nsAbDirectoryQueryMatchItem::Create(nsISupports* aOuter, REFNSIID aIID,
void* *aResult)
{
if (aOuter)
return NS_ERROR_NO_AGGREGATION;
nsAbDirectoryQueryMatchItem* it = new nsAbDirectoryQueryMatchItem();
if (it == NULL)
return NS_ERROR_OUT_OF_MEMORY;
NS_ADDREF(it);
nsresult rv = it->QueryInterface(aIID, aResult);
NS_RELEASE(it);
return rv;
}
NS_COM nsresult NS_NewIAbDirectoryQueryMatchItem(nsIAbDirectoryQueryMatchItem**
aInstancePtrResult)
{
nsresult rv;
rv = nsAbDirectoryQueryMatchItem::Create(NULL,
NS_GET_IID(nsIAbDirectoryQueryMatchItem),
(void**)aInstancePtrResult);
return rv;
}
NS_IMPL_ISUPPORTS1(nsAbDirectoryQueryArguments, nsIAbDirectoryQueryArguments)
nsAbDirectoryQueryArguments::nsAbDirectoryQueryArguments() :
mMatchItemsType (matchItemsAll),
mQuerySubDirectories (PR_TRUE)
{
NS_INIT_ISUPPORTS();
}
nsAbDirectoryQueryArguments::~nsAbDirectoryQueryArguments()
{
}
/* attribute nsISupportsArray matchItems; */
NS_IMETHODIMP nsAbDirectoryQueryArguments::GetMatchItems(nsISupportsArray*
*aMatchItems)
{
if (!mMatchItems)
NS_NewISupportsArray(getter_AddRefs(mMatchItems));
*aMatchItems = mMatchItems;
NS_ADDREF(*aMatchItems);
return NS_OK;
}
NS_IMETHODIMP nsAbDirectoryQueryArguments::SetMatchItems(nsISupportsArray*
aMatchItems)
{
mMatchItems = aMatchItems;
return NS_OK;
}
/* void asetMatchItems (in unsigned long aMatchItemsSize, [array, size_is
(aMatchItemsSize)] in nsIAbDirectoryQueryMatchItem aMatchItemsArray); */
NS_IMETHODIMP nsAbDirectoryQueryArguments::AsetMatchItems(PRUint32 aMatchItemsSize,
nsIAbDirectoryQueryMatchItem* *aMatchItemsArray)
{
return NS_ERROR_NOT_IMPLEMENTED;
}
/* void agetMatchItems (out unsigned long aMatchItemsSize, [array, size_is
(aMatchItemsSize), retval] out nsIAbDirectoryQueryMatchItem aMatchItemsArray); */
NS_IMETHODIMP nsAbDirectoryQueryArguments::AgetMatchItems(PRUint32 *aMatchItemsSize,
nsIAbDirectoryQueryMatchItem* **aMatchItemsArray)
{
return NS_ERROR_NOT_IMPLEMENTED;
}
/* attribute long matchItemsType; */
NS_IMETHODIMP nsAbDirectoryQueryArguments::GetMatchItemsType(PRInt32 *aMatchItemsType)
{
*aMatchItemsType = mMatchItemsType;
return NS_OK;
}
NS_IMETHODIMP nsAbDirectoryQueryArguments::SetMatchItemsType(PRInt32 aMatchItemsType)
{
mMatchItemsType = aMatchItemsType;
return NS_OK;
}
/* attribute boolean querySubDirectories; */
NS_IMETHODIMP nsAbDirectoryQueryArguments::GetQuerySubDirectories(PRBool*
aQuerySubDirectories)
{
*aQuerySubDirectories = mQuerySubDirectories;
return NS_OK;
}
NS_IMETHODIMP nsAbDirectoryQueryArguments::SetQuerySubDirectories(PRBool
aQuerySubDirectories)
{
mQuerySubDirectories = aQuerySubDirectories;
return NS_OK;
}
/* attribute nsISupportsArray returnProperties; */
NS_IMETHODIMP nsAbDirectoryQueryArguments::GetReturnProperties(nsISupportsArray*
*aReturnProperties)
{
if (!mReturnProperties)
NS_NewISupportsArray(getter_AddRefs(mReturnProperties));
*aReturnProperties = mReturnProperties;
NS_ADDREF(*aReturnProperties);
return NS_OK;
}
NS_IMETHODIMP nsAbDirectoryQueryArguments::SetReturnProperties(nsISupportsArray*
aReturnProperties)
{
mReturnProperties = aReturnProperties;
return NS_OK;
}
/* void asetReturnProperties (in unsigned long aReturnPropertiesSize, [array, size_is
(aReturnPropertiesSize)] in string aReturnPropertiesArray); */
NS_IMETHODIMP nsAbDirectoryQueryArguments::AsetReturnProperties(PRUint32
aReturnPropertiesSize, const char* *aReturnPropertiesArray)
{
return NS_ERROR_NOT_IMPLEMENTED;
}
/* void agetReturnProperties (out unsigned long aReturnPropertiesSize, [array, size_is
(aReturnPropertiesSize), retval] out string aReturnPropertiesArray); */
NS_IMETHODIMP nsAbDirectoryQueryArguments::AgetReturnProperties(PRUint32
*aReturnPropertiesSize, char* **aReturnPropertiesArray)
{
return NS_ERROR_NOT_IMPLEMENTED;
}
NS_METHOD nsAbDirectoryQueryArguments::Create(nsISupports* aOuter, REFNSIID aIID,
void* *aResult)
{
if (aOuter)
return NS_ERROR_NO_AGGREGATION;
nsAbDirectoryQueryArguments* it = new nsAbDirectoryQueryArguments();
if (it == NULL)
return NS_ERROR_OUT_OF_MEMORY;
NS_ADDREF(it);
nsresult rv = it->QueryInterface(aIID, aResult);
NS_RELEASE(it);
return rv;
}
NS_COM nsresult NS_NewIAbDirectoryQueryArguments(nsIAbDirectoryQueryArguments**
aInstancePtrResult)
{
nsresult rv;
rv = nsAbDirectoryQueryArguments::Create(NULL,
NS_GET_IID(nsIAbDirectoryQueryArguments),
(void**)aInstancePtrResult);
return rv;
}
NS_IMPL_ISUPPORTS1(nsAbDirectoryQueryResult, nsIAbDirectoryQueryResult)
nsAbDirectoryQueryResult::nsAbDirectoryQueryResult() :
mContextID (-1),
mType (queryResultError)
{
NS_INIT_ISUPPORTS();
}
nsAbDirectoryQueryResult::nsAbDirectoryQueryResult(PRInt32 aContextID,
nsIAbDirectoryQueryArguments* aContextArgs,
PRInt32 aType,
nsCOMPtr<nsISupportsArray> aResult)
{
NS_INIT_ISUPPORTS();
mContextID = aContextID;
mContextArgs = aContextArgs;
mType = aType;
mResult = aResult;
}
nsAbDirectoryQueryResult::~nsAbDirectoryQueryResult()
{
}
/* readonly attribute long contextID; */
NS_IMETHODIMP nsAbDirectoryQueryResult::GetContextID(PRInt32 *aContextID)
{
*aContextID = mContextID;
return NS_OK;
}
/* readonly attribute nsIAbDirectoryQueryArguments contextArgs; */
NS_IMETHODIMP nsAbDirectoryQueryResult::GetContextArgs(nsIAbDirectoryQueryArguments*
*aContextArgs)
{
if (!mContextArgs)
return NS_ERROR_NULL_POINTER;
*aContextArgs = mContextArgs;
NS_ADDREF(*aContextArgs);
return NS_OK;
}
/* readonly attribute long type; */
NS_IMETHODIMP nsAbDirectoryQueryResult::GetType(PRInt32 *aType)
{
*aType = mType;
return NS_OK;
}
/* readonly attribute nsISupportsArray result; */
NS_IMETHODIMP nsAbDirectoryQueryResult::GetResult(nsISupportsArray* *aResult)
{
if (!mResult)
return NS_ERROR_NULL_POINTER;
*aResult = mResult;
NS_ADDREF(*aResult);
return NS_OK;
}
/* void agetResult (out unsigned long aResultSize, [array, size_is (aResultSize),
retval] out nsISupports aResultArray); */
NS_IMETHODIMP nsAbDirectoryQueryResult::AgetResult(PRUint32 *aResultSize, nsISupports*
**aResultArray)
{
return NS_ERROR_NOT_IMPLEMENTED;
}
/* Implementation file */
NS_IMPL_ISUPPORTS1(nsAbDirectoryQuery, nsIAbDirectoryQuery)
nsAbDirectoryQuery::nsAbDirectoryQuery(nsIAbDirectory* aDirectory)
{
NS_INIT_ISUPPORTS();
mDirectory = aDirectory;
}
nsAbDirectoryQuery::~nsAbDirectoryQuery()
{
}
/* long doQuery (in nsIAbDirectoryQueryArguments arguments, in
nsIAbDirectoryQueryResultListener listener, in long resultLimit); */
NS_IMETHODIMP nsAbDirectoryQuery::DoQuery(nsIAbDirectoryQueryArguments* arguments,
nsIAbDirectoryQueryResultListener* listener, PRInt32 resultLimit, PRInt32* _retval)
{
nsresult rv;
rv = query (mDirectory, arguments, listener, &resultLimit);
if (NS_FAILED(rv))
rv = queryError (arguments, listener);
else
rv = queryFinished (arguments, listener);
*_retval = 0;
return rv;
}
/* void stopQuery (in long contextID); */
NS_IMETHODIMP nsAbDirectoryQuery::StopQuery(PRInt32 contextID)
{
return NS_OK;
}
nsresult nsAbDirectoryQuery::query (nsIAbDirectory* directory,
nsIAbDirectoryQueryArguments* arguments,
nsIAbDirectoryQueryResultListener* listener,
PRInt32* resultLimit)
{
nsresult rv = NS_OK;
if (resultLimit == 0)
return rv;
rv = queryCards (directory, arguments, listener, resultLimit);
NS_ENSURE_SUCCESS(rv, rv);
PRBool doSubDirectories;
arguments->GetQuerySubDirectories (&doSubDirectories);
if (doSubDirectories == PR_TRUE && *resultLimit != 0)
{
rv = queryChildren (directory, arguments, listener, resultLimit);
NS_ENSURE_SUCCESS(rv, rv);
}
return rv;
}
nsresult nsAbDirectoryQuery::queryChildren (nsIAbDirectory* directory,
nsIAbDirectoryQueryArguments* arguments,
nsIAbDirectoryQueryResultListener* listener,
PRInt32* resultLimit)
{
nsresult rv = NS_OK;
nsCOMPtr<nsIEnumerator> subDirectories;
rv = directory->GetChildNodes(getter_AddRefs(subDirectories));
NS_ENSURE_SUCCESS(rv, rv);
rv = subDirectories->First ();
if (NS_FAILED(rv))
return NS_OK;
do
{
nsCOMPtr<nsISupports> item;
rv = subDirectories->CurrentItem (getter_AddRefs (item));
NS_ENSURE_SUCCESS(rv, rv);
nsCOMPtr<nsIAbDirectory> subDirectory(do_QueryInterface(item, &rv));
NS_ENSURE_SUCCESS(rv, rv);
rv = query (subDirectory, arguments, listener, resultLimit);
NS_ENSURE_SUCCESS(rv, rv);
rv = subDirectories->Next ();
}
while (rv == NS_OK);
return NS_OK;
}
nsresult nsAbDirectoryQuery::queryCards (nsIAbDirectory* directory,
nsIAbDirectoryQueryArguments* arguments,
nsIAbDirectoryQueryResultListener* listener,
PRInt32* resultLimit)
{
nsresult rv = NS_OK;
nsCOMPtr<nsIEnumerator> cards;
rv = directory->GetChildCards(getter_AddRefs(cards));
if (NS_FAILED(rv))
{
if (rv != NS_ERROR_NOT_IMPLEMENTED)
NS_ENSURE_SUCCESS(rv, rv);
else
return NS_OK;
}
if (!cards)
return NS_OK;
rv = cards->First ();
if (NS_FAILED(rv))
return NS_OK;
do
{
nsCOMPtr<nsISupports> item;
rv = cards->CurrentItem (getter_AddRefs (item));
NS_ENSURE_SUCCESS(rv, rv);
nsCOMPtr<nsIAbCard> card(do_QueryInterface(item, &rv));
NS_ENSURE_SUCCESS(rv, rv);
rv = matchCard (card, arguments, listener, resultLimit);
NS_ENSURE_SUCCESS(rv, rv);
if (*resultLimit == 0)
return NS_OK;
rv = cards->Next ();
}
while (rv == NS_OK);
return NS_OK;
}
nsresult nsAbDirectoryQuery::matchCard (nsIAbCard* card,
nsIAbDirectoryQueryArguments* arguments,
nsIAbDirectoryQueryResultListener* listener,
PRInt32* resultLimit)
{
nsresult rv = NS_OK;
PRInt32 matchItemsType;
rv = arguments->GetMatchItemsType (&matchItemsType);
NS_ENSURE_SUCCESS(rv, rv);
nsCOMPtr<nsISupportsArray> matchItems;
rv = arguments->GetMatchItems (getter_AddRefs (matchItems));
NS_ENSURE_SUCCESS(rv, rv);
PRUint32 count;
rv = matchItems->Count (&count);
NS_ENSURE_SUCCESS(rv, rv);
PRBool matchFound = PR_FALSE;
for (PRUint32 i = 0; i < count; i++)
{
nsCOMPtr<nsISupports> item;
rv = matchItems->GetElementAt (i, getter_AddRefs (item));
NS_ENSURE_SUCCESS(rv, rv);
nsCOMPtr<nsIAbDirectoryQueryMatchItem>
matchItem(do_QueryInterface(item, &rv));
NS_ENSURE_SUCCESS(rv, rv);
rv = matchCardMatchItem (card, matchItem, &matchFound);
if (matchFound == PR_TRUE &&
matchItemsType ==
nsIAbDirectoryQueryArguments::matchItemsOneOrMore)
break;
else if (matchFound == PR_FALSE &&
matchItemsType == nsIAbDirectoryQueryArguments::matchItemsAll)
break;
}
if (matchFound == PR_TRUE)
{
(*resultLimit)--;
rv = queryMatch (card, arguments, listener);
NS_ENSURE_SUCCESS(rv, rv);
}
return rv;
}
nsresult nsAbDirectoryQuery::matchCardMatchItem (nsIAbCard* card,
nsIAbDirectoryQueryMatchItem* matchItem,
PRBool* matchFound)
{
nsresult rv = NS_OK;
PRInt32 matchType;
rv = matchItem->GetMatchType (&matchType);
NS_ENSURE_SUCCESS(rv, rv);
nsXPIDLCString name;
rv = matchItem->GetName (getter_Copies (name));
NS_ENSURE_SUCCESS(rv, rv);
nsCString n (name.get ());
if (n == "card:URI" || n == "card:nsIAbCard")
{
if (matchType == nsIAbDirectoryQueryMatchItem::matchExists)
*matchFound = PR_TRUE;
else
*matchFound = PR_FALSE;
return NS_OK;
}
nsXPIDLString value;
rv = card->GetCardValue (name, getter_Copies (value));
NS_ENSURE_SUCCESS(rv, rv);
const PRUnichar* uvalue = value.get ();
if (!uvalue || nsCRT::strlen (uvalue) == 0)
{
if (matchType == nsIAbDirectoryQueryMatchItem::matchDoesNotExist)
*matchFound = PR_TRUE;
else
*matchFound = PR_FALSE;
return NS_OK;
}
nsXPIDLString matchValue;
rv = matchItem->GetMatchValue (getter_Copies (matchValue));
NS_ENSURE_SUCCESS(rv, rv);
/* TODO
* What about case insensitive comparisions
*
*/
switch (matchType)
{
case nsIAbDirectoryQueryMatchItem::matchExists:
*matchFound = PR_TRUE;
break;
case nsIAbDirectoryQueryMatchItem::matchContains:
case nsIAbDirectoryQueryMatchItem::matchDoesNotContain:
*matchFound = PR_FALSE;
break;
case nsIAbDirectoryQueryMatchItem::matchIs:
*matchFound = nsCRT::strcmp (value, matchValue) == 0;
break;
case nsIAbDirectoryQueryMatchItem::matchIsNot:
*matchFound = nsCRT::strcmp (value, matchValue) != 0;
break;
case nsIAbDirectoryQueryMatchItem::matchBeginsWith:
*matchFound = nsCRT::strncmp(value, matchValue,
nsCRT::strlen (matchValue)) == 0;
break;
case nsIAbDirectoryQueryMatchItem::matchEndsWith:
case nsIAbDirectoryQueryMatchItem::matchSoundsLike:
case nsIAbDirectoryQueryMatchItem::matchRegExp:
*matchFound = PR_FALSE;
break;
default:
*matchFound = PR_FALSE;
}
return rv;
}
nsresult nsAbDirectoryQuery::queryMatch (nsIAbCard* card,
nsIAbDirectoryQueryArguments* arguments,
nsIAbDirectoryQueryResultListener* listener)
{
nsresult rv;
nsCOMPtr<nsISupportsArray> propertyValues;
nsCOMPtr<nsISupportsArray> properties;
rv = arguments->GetReturnProperties (getter_AddRefs (properties));
NS_ENSURE_SUCCESS(rv, rv);
PRUint32 count;
rv = properties->Count (&count);
NS_ENSURE_SUCCESS(rv, rv);
for (PRUint32 i = 0; i < count; i++)
{
nsCOMPtr<nsISupports> item;
rv = properties->GetElementAt (i, getter_AddRefs (item));
NS_ENSURE_SUCCESS(rv, rv);
nsCOMPtr<nsIAbDirectoryQueryProperty> property(do_QueryInterface(item,
&rv));
NS_ENSURE_SUCCESS(rv, rv);
nsXPIDLCString name;
rv = property->GetName (getter_Copies (name));
NS_ENSURE_SUCCESS(rv, rv);
nsCString n (name.get ());
nsAbDirectoryQueryPropertyValue* _propertyValue = 0;
if (n == "card:nsIAbCard")
{
nsCOMPtr<nsISupports> supports(do_QueryInterface(card, &rv));
NS_ENSURE_SUCCESS(rv, rv);
_propertyValue = new nsAbDirectoryQueryPropertyValue(n,
supports);
}
else if (n == "card:URI")
{
nsCOMPtr<nsIRDFResource> rdfResource(do_QueryInterface(card,
&rv));
NS_ENSURE_SUCCESS(rv, rv);
nsXPIDLCString uri;
rv = rdfResource->GetValue (getter_Copies (uri));
NS_ENSURE_SUCCESS(rv, rv);
nsString v;
v.AssignWithConversion (uri.get ());
_propertyValue = new nsAbDirectoryQueryPropertyValue(n, v);
}
else
{
nsXPIDLString value;
rv = card->GetCardValue (name, getter_Copies (value));
NS_ENSURE_SUCCESS(rv, rv);
const PRUnichar* uvalue = value.get ();
if (!uvalue || nsCRT::strlen (uvalue) == 0)
continue;
nsString v (uvalue);
_propertyValue = new nsAbDirectoryQueryPropertyValue(n, v);
}
if (_propertyValue)
{
nsCOMPtr<nsIAbDirectoryQueryPropertyValue> propertyValue;
propertyValue = getter_AddRefs(_propertyValue);
if (!propertyValues)
{
NS_NewISupportsArray(getter_AddRefs(propertyValues));
}
nsCOMPtr<nsISupports>
supports(do_QueryInterface(propertyValue, &rv));
NS_ENSURE_SUCCESS(rv, rv);
propertyValues->AppendElement (supports);
}
}
if (!propertyValues)
return NS_OK;
nsCOMPtr<nsIAbDirectoryQueryResult> queryResult;
nsAbDirectoryQueryResult* _queryResult = new nsAbDirectoryQueryResult (0,
arguments,
nsIAbDirectoryQueryResult::queryResultMatch,
propertyValues);
queryResult = getter_AddRefs(_queryResult);
rv = listener->OnQueryItem (queryResult);
return rv;
}
nsresult nsAbDirectoryQuery::queryFinished (nsIAbDirectoryQueryArguments* arguments,
nsIAbDirectoryQueryResultListener* listener)
{
nsCOMPtr<nsIAbDirectoryQueryResult> queryResult;
nsAbDirectoryQueryResult* _queryResult = new nsAbDirectoryQueryResult (0,
arguments,
nsIAbDirectoryQueryResult::queryResultComplete,
0);
queryResult = getter_AddRefs(_queryResult);
return listener->OnQueryItem (queryResult);
}
nsresult nsAbDirectoryQuery::queryError (nsIAbDirectoryQueryArguments* arguments,
nsIAbDirectoryQueryResultListener* listener)
{
nsCOMPtr<nsIAbDirectoryQueryResult> queryResult;
nsAbDirectoryQueryResult* _queryResult = new nsAbDirectoryQueryResult (0,
arguments,
nsIAbDirectoryQueryResult::queryResultError,
0);
queryResult = getter_AddRefs(_queryResult);
return listener->OnQueryItem (queryResult);
}
NS_IMPL_ISUPPORTS1(nsAbDirectoryQueryAutoComplete, nsIAbDirectoryQueryResultListener)
nsAbDirectoryQueryAutoComplete::nsAbDirectoryQueryAutoComplete()
{
NS_INIT_ISUPPORTS();
}
nsAbDirectoryQueryAutoComplete::~nsAbDirectoryQueryAutoComplete()
{
}
/* void onQueryItem (in nsIAbDirectoryQueryResult result); */
NS_IMETHODIMP nsAbDirectoryQueryAutoComplete::OnQueryItem(nsIAbDirectoryQueryResult
*result)
{
nsresult rv;
PRInt32 resultType;
printf ("IN nsAbDirectoryQueryAutoComplete::OnQueryItem\n");
result->GetType (&resultType);
printf ("Type: ");
if (resultType == nsIAbDirectoryQueryResult::queryResultError)
{
printf ("queryResultError\n");
printf ("OUT nsAbDirectoryQueryAutoComplete::OnQueryItem\n");
return NS_OK;
}
if (resultType == nsIAbDirectoryQueryResult::queryResultStopped)
{
printf ("queryResultStopped\n");
printf ("OUT nsAbDirectoryQueryAutoComplete::OnQueryItem\n");
return NS_OK;
}
if (resultType == nsIAbDirectoryQueryResult::queryResultComplete)
{
printf ("queryResultComplete\n");
printf ("OUT nsAbDirectoryQueryAutoComplete::OnQueryItem\n");
return NS_OK;
}
printf ("queryResultMatch\n");
nsCOMPtr<nsISupportsArray> properties;
rv = result->GetResult (getter_AddRefs (properties));
NS_ENSURE_SUCCESS(rv, rv);
PRUint32 count;
rv = properties->Count (&count);
NS_ENSURE_SUCCESS(rv, rv);
printf ("Properties for match: %d\n", count);
for (PRUint32 i = 0; i < count; i++)
{
nsCOMPtr<nsISupports> item;
rv = properties->GetElementAt (i, getter_AddRefs (item));
NS_ENSURE_SUCCESS(rv, rv);
nsCOMPtr<nsIAbDirectoryQueryPropertyValue>
property(do_QueryInterface(item, &rv));
NS_ENSURE_SUCCESS(rv, rv);
nsXPIDLCString name;
rv = property->GetName (getter_Copies (name));
NS_ENSURE_SUCCESS(rv, rv);
nsCString n (name.get ());
printf ("Property %d: %s\n", i, name.get ());
if (n == "card:nsIAbCard")
{
nsCOMPtr<nsISupports> cardSupports;
property->GetValueISupports (getter_AddRefs (cardSupports));
nsCOMPtr<nsIAbCard> card(do_QueryInterface(cardSupports, &rv));
NS_ENSURE_SUCCESS(rv, rv);
printf ("Value [Card]: 0x%x\n", card);
}
else
{
nsXPIDLString v;
property->GetValue (getter_Copies (v));
nsString value (v);
nsCString cvalue;
cvalue.AssignWithConversion (v);
printf ("Value [string]: %s\n", cvalue.get ());
}
}
printf ("OUT nsAbDirectoryQueryAutoComplete::OnQueryItem\n");
return NS_OK;
}
nsresult nsAbDirectoryQueryAutoComplete::Start (nsIAbDirectory* directory)
{
nsresult rv;
nsCOMPtr<nsIAbDirectoryQuery> directoryQuery;
nsAbDirectoryQuery* _directoryQuery = new nsAbDirectoryQuery (directory);
directoryQuery = getter_AddRefs (_directoryQuery);
nsString matchValue;
matchValue.AssignWithConversion ("paul");
nsCOMPtr<nsIAbDirectoryQueryMatchItem> matchNickName;
NS_NewIAbDirectoryQueryMatchItem (getter_AddRefs (matchNickName));
matchNickName->SetName ("NickName");
matchNickName->SetMatchType (nsIAbDirectoryQueryMatchItem::matchIs);
matchNickName->SetMatchValue (matchValue.GetUnicode ());
nsCOMPtr<nsIAbDirectoryQueryMatchItem> matchName;
NS_NewIAbDirectoryQueryMatchItem (getter_AddRefs (matchName));
matchName->SetName ("DisplayName");
matchName->SetMatchType (nsIAbDirectoryQueryMatchItem::matchIs);
matchName->SetMatchValue (matchValue.GetUnicode ());
nsCOMPtr<nsIAbDirectoryQueryMatchItem> matchEmail;
NS_NewIAbDirectoryQueryMatchItem (getter_AddRefs (matchEmail));
matchEmail->SetName ("PrimaryEmail");
matchEmail->SetMatchType (nsIAbDirectoryQueryMatchItem::matchIs);
matchEmail->SetMatchValue (matchValue.GetUnicode ());
nsCOMPtr<nsIAbDirectoryQueryMatchItem> matchNickNamePartial;
NS_NewIAbDirectoryQueryMatchItem (getter_AddRefs (matchNickNamePartial));
matchNickNamePartial->SetName ("NickName");
matchNickNamePartial->SetMatchType
(nsIAbDirectoryQueryMatchItem::matchBeginsWith);
matchNickNamePartial->SetMatchValue (matchValue.GetUnicode ());
nsCOMPtr<nsIAbDirectoryQueryMatchItem> matchNamePartial;
NS_NewIAbDirectoryQueryMatchItem (getter_AddRefs (matchNamePartial));
matchNamePartial->SetName ("DisplayName");
matchNamePartial->SetMatchType (nsIAbDirectoryQueryMatchItem::matchBeginsWith);
matchNamePartial->SetMatchValue (matchValue.GetUnicode ());
nsCOMPtr<nsIAbDirectoryQueryMatchItem> matchEmailPartial;
NS_NewIAbDirectoryQueryMatchItem (getter_AddRefs (matchEmailPartial));
matchEmailPartial->SetName ("PrimaryEmail");
matchEmailPartial->SetMatchType
(nsIAbDirectoryQueryMatchItem::matchBeginsWith);
matchEmailPartial->SetMatchValue (matchValue.GetUnicode ());
nsCOMPtr<nsISupportsArray> matchItems;
NS_NewISupportsArray(getter_AddRefs(matchItems));
matchItems->AppendElement (matchNickName);
matchItems->AppendElement (matchName);
matchItems->AppendElement (matchEmail);
matchItems->AppendElement (matchNickNamePartial);
matchItems->AppendElement (matchNamePartial);
matchItems->AppendElement (matchEmailPartial);
nsCOMPtr<nsIAbDirectoryQueryProperty> propertyCard;
NS_NewIAbDirectoryQueryProperty (getter_AddRefs (propertyCard));
propertyCard->SetName ("card:nsIAbCard");
nsCOMPtr<nsIAbDirectoryQueryProperty> propertyCardURI;
NS_NewIAbDirectoryQueryProperty (getter_AddRefs (propertyCardURI));
propertyCardURI->SetName ("card:URI");
nsCOMPtr<nsISupportsArray> returnProperties;
NS_NewISupportsArray(getter_AddRefs(returnProperties));
returnProperties->AppendElement (matchEmail);
returnProperties->AppendElement (propertyCard);
returnProperties->AppendElement (propertyCardURI);
nsCOMPtr<nsIAbDirectoryQueryArguments> arguments;
NS_NewIAbDirectoryQueryArguments (getter_AddRefs(arguments));
arguments->SetMatchItems (matchItems);
arguments->SetReturnProperties (returnProperties);
arguments->SetMatchItemsType
(nsIAbDirectoryQueryArguments::matchItemsOneOrMore);
arguments->SetQuerySubDirectories (PR_TRUE);
PRInt32 context;
rv = directoryQuery->DoQuery (arguments, this, 100, &context);
return rv;
}
moz.gif