Bommels05/Mozilla
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Bug #387709 --> make the addresss book datasource a cycle collector participant. This fixes a shut down leak of the address book data source.

Browse Source 
NPOTB for the firefox freeze.

r=standard8


git-svn-id: svn://10.0.0.236/trunk@231130 18797224-902f-48f8-a5cc-f745e15eee43
This commit is contained in:
scott%scott-macgregor.org
2007-07-28 16:31:47 +00:00
parent ea7110b26f
commit b85f2bc72c
4 changed files with 444 additions and 488 deletions
Download Patch File Download Diff File Expand all files Collapse all files

369
mozilla/mailnews/addrbook/src/nsAbRDFDataSource.cpp
View File

@@ -63,21 +63,18 @@ typedef struct _nsAbRDFNotification {
nsIRDFResource *property;
nsIRDFNode *object;
} nsAbRDFNotification;
nsresult nsAbRDFDataSource::createNode(const PRUnichar *str, nsIRDFNode **node)
{
*node = nsnull;
nsresult rv;
nsCOMPtr<nsIRDFService> rdf(do_GetService("@mozilla.org/rdf/rdf-service;1", &rv));
NS_ENSURE_SUCCESS(rv, rv); // always check this before proceeding
nsCOMPtr<nsIRDFLiteral> value;
rv = rdf->GetLiteral(str, getter_AddRefs(value));
if (NS_SUCCEEDED(rv))
{
NS_IF_ADDREF(*node = value);
}
return rv;
*node = nsnull;
nsresult rv;
nsCOMPtr<nsIRDFService> rdf(do_GetService("@mozilla.org/rdf/rdf-service;1", &rv));
NS_ENSURE_SUCCESS(rv, rv); // always check this before proceeding
nsCOMPtr<nsIRDFLiteral> value;
rv = rdf->GetLiteral(str, getter_AddRefs(value));
if (NS_SUCCEEDED(rv))
NS_IF_ADDREF(*node = value);
return rv;
}
nsresult nsAbRDFDataSource::createBlobNode(PRUint8 *value, PRUint32 &length, nsIRDFNode **node, nsIRDFService *rdfService)
@@ -93,36 +90,30 @@ nsresult nsAbRDFDataSource::createBlobNode(PRUint8 *value, PRUint32 &length, nsI
return rv;
}
PRBool nsAbRDFDataSource::changeEnumFunc(nsISupports *aElement, void *aData)
PRBool nsAbRDFDataSource::changeEnumFunc(nsIRDFObserver *aObserver, void *aData)
{
nsAbRDFNotification* note = (nsAbRDFNotification *)aData;
nsIRDFObserver* observer = (nsIRDFObserver *)aElement;
observer->OnChange(note->datasource,
aObserver->OnChange(note->datasource,
note->subject,
note->property,
nsnull, note->object);
return PR_TRUE;
}
PRBool nsAbRDFDataSource::assertEnumFunc(nsISupports *aElement, void *aData)
PRBool nsAbRDFDataSource::assertEnumFunc(nsIRDFObserver *aObserver, void *aData)
{
nsAbRDFNotification *note = (nsAbRDFNotification *)aData;
nsIRDFObserver* observer = (nsIRDFObserver *)aElement;
observer->OnAssert(note->datasource,
aObserver->OnAssert(note->datasource,
note->subject,
note->property,
note->object);
return PR_TRUE;
}
PRBool nsAbRDFDataSource::unassertEnumFunc(nsISupports *aElement, void *aData)
PRBool nsAbRDFDataSource::unassertEnumFunc(nsIRDFObserver *aObserver, void *aData)
{
nsAbRDFNotification* note = (nsAbRDFNotification *)aData;
nsIRDFObserver* observer = (nsIRDFObserver *)aElement;
observer->OnUnassert(note->datasource,
aObserver->OnUnassert(note->datasource,
note->subject,
note->property,
note->object);
@@ -130,166 +121,162 @@ PRBool nsAbRDFDataSource::unassertEnumFunc(nsISupports *aElement, void *aData)
}
nsresult nsAbRDFDataSource::CreateProxyObserver (nsIRDFObserver* observer,
nsIRDFObserver** proxyObserver)
nsIRDFObserver** proxyObserver)
{
nsresult rv;
nsresult rv;
// Proxy the observer on the UI thread
/*
* TODO
* Currenly using NS_PROXY_ASYNC, however
* this can flood the event queue if
* rate of events on the observer is
* greater that the time to process the
* events.
* This causes the UI to pause.
*/
rv = NS_GetProxyForObject (
// Proxy the observer on the UI thread
/*
* TODO
* Currenly using NS_PROXY_ASYNC, however
* this can flood the event queue if
* rate of events on the observer is
* greater that the time to process the
* events.
* This causes the UI to pause.
*/
rv = NS_GetProxyForObject (
NS_PROXY_TO_MAIN_THREAD,
NS_GET_IID(nsIRDFObserver),
observer,
NS_PROXY_ASYNC | NS_PROXY_ALWAYS,
(void** )proxyObserver);
NS_GET_IID(nsIRDFObserver),
observer,
NS_PROXY_ASYNC | NS_PROXY_ALWAYS,
(void** )proxyObserver);
return rv;
return rv;
}
nsresult nsAbRDFDataSource::CreateProxyObservers ()
{
nsresult rv = NS_OK;
nsresult rv = NS_OK;
PRUint32 nObservers;
mObservers->Count (&nObservers);
PRUint32 nObservers = mObservers.Count();
if (!mProxyObservers)
{
rv = NS_NewISupportsArray(getter_AddRefs(mProxyObservers));
NS_ENSURE_SUCCESS(rv, rv);
}
PRUint32 nProxyObservers = mProxyObservers.Count();
PRUint32 nProxyObservers;
mProxyObservers->Count (&nProxyObservers);
/*
* For all the outstanding observers that
* have not been proxied
*/
for (PRUint32 i = nProxyObservers; i < nObservers; i++)
{
nsIRDFObserver * observer = mObservers.ObjectAt(i);
/*
* For all the outstanding observers that
* have not been proxied
*/
for (PRUint32 i = nProxyObservers; i < nObservers; i++)
{
nsCOMPtr<nsISupports> supports;
rv = mObservers->GetElementAt (i, getter_AddRefs (supports));
NS_ENSURE_SUCCESS(rv, rv);
// Create the proxy
nsCOMPtr<nsIRDFObserver> proxyObserver;
rv = CreateProxyObserver (observer, getter_AddRefs (proxyObserver));
NS_ENSURE_SUCCESS(rv, rv);
mProxyObservers.AppendObject(proxyObserver);
}
nsCOMPtr<nsIRDFObserver> observer (do_QueryInterface (supports, &rv));
NS_ENSURE_SUCCESS(rv, rv);
// Create the proxy
nsCOMPtr<nsIRDFObserver> proxyObserver;
rv = CreateProxyObserver (observer, getter_AddRefs (proxyObserver));
NS_ENSURE_SUCCESS(rv, rv);
mProxyObservers->AppendElement(proxyObserver);
}
return rv;
return rv;
}
nsresult nsAbRDFDataSource::NotifyObservers(nsIRDFResource *subject,
nsIRDFResource *property,
nsIRDFNode *object,
PRBool assert,
PRBool change)
nsIRDFResource *property,
nsIRDFNode *object,
PRBool assert,
PRBool change)
{
NS_ASSERTION(!(change && assert),
NS_ASSERTION(!(change && assert),
"Can't change and assert at the same time!\n");
if(!mLock)
{
NS_ERROR("Error in AutoLock resource in nsAbRDFDataSource::NotifyObservers()");
return NS_ERROR_OUT_OF_MEMORY;
}
if(!mLock)
{
NS_ERROR("Error in AutoLock resource in nsAbRDFDataSource::NotifyObservers()");
return NS_ERROR_OUT_OF_MEMORY;
}
nsresult rv;
nsresult rv;
nsAutoLock lockGuard (mLock);
nsAutoLock lockGuard (mLock);
if (!mObservers)
return NS_OK;
/*
* TODO
* Is the main thread always guaranteed to be
* the UI thread?
*
* Note that this also binds the data source
* to the UI which is supposedly the only
* place where it is used, but what about
* RDF datasources that are not UI specific
* but are used in the UI?
*/
nsCOMArray<nsIRDFObserver> * observers;
if (NS_IsMainThread())
{
/*
* Since this is the UI Thread use the
* observers list directly for performance
*/
observers = &mObservers;
}
else
{
/*
* This is a different thread to the UI
* thread need to use proxies to the
* observers
*
* Create the proxies
*/
rv = CreateProxyObservers();
NS_ENSURE_SUCCESS (rv, rv);
observers = &mProxyObservers;
}
nsAbRDFNotification note = { this, subject, property, object };
if (change)
observers->EnumerateForwards(changeEnumFunc, &note);
else if (assert)
observers->EnumerateForwards(assertEnumFunc, &note);
else
observers->EnumerateForwards(unassertEnumFunc, &note);
/*
* TODO
* Is the main thread always guaranteed to be
* the UI thread?
*
* Note that this also binds the data source
* to the UI which is supposedly the only
* place where it is used, but what about
* RDF datasources that are not UI specific
* but are used in the UI?
*/
nsCOMPtr<nsISupportsArray> observers;
if (NS_IsMainThread())
{
/*
* Since this is the UI Thread use the
* observers list directly for performance
*/
observers = mObservers;
}
else
{
/*
* This is a different thread to the UI
* thread need to use proxies to the
* observers
*
* Create the proxies
*/
rv = CreateProxyObservers ();
NS_ENSURE_SUCCESS (rv, rv);
observers = mProxyObservers;
}
nsAbRDFNotification note = { this, subject, property, object };
if (change)
observers->EnumerateForwards(changeEnumFunc, &note);
else if (assert)
observers->EnumerateForwards(assertEnumFunc, &note);
else
observers->EnumerateForwards(unassertEnumFunc, &note);
return NS_OK;
return NS_OK;
}
nsresult nsAbRDFDataSource::NotifyPropertyChanged(nsIRDFResource *resource,
nsIRDFResource *propertyResource,
const PRUnichar *oldValue,
const PRUnichar *newValue)
nsIRDFResource *propertyResource,
const PRUnichar *oldValue,
const PRUnichar *newValue)
{
nsCOMPtr<nsIRDFNode> newValueNode;
createNode(newValue, getter_AddRefs(newValueNode));
NotifyObservers(resource, propertyResource, newValueNode, PR_FALSE, PR_TRUE);
return NS_OK;
nsCOMPtr<nsIRDFNode> newValueNode;
createNode(newValue, getter_AddRefs(newValueNode));
NotifyObservers(resource, propertyResource, newValueNode, PR_FALSE, PR_TRUE);
return NS_OK;
}
nsAbRDFDataSource::nsAbRDFDataSource():
mObservers(nsnull),
mProxyObservers(nsnull),
mLock(nsnull)
{
mLock = PR_NewLock ();
mLock = PR_NewLock ();
}
nsAbRDFDataSource::~nsAbRDFDataSource (void)
{
if(mLock)
PR_DestroyLock (mLock);
if(mLock)
PR_DestroyLock (mLock);
}
NS_IMPL_THREADSAFE_ISUPPORTS1(nsAbRDFDataSource, nsIRDFDataSource)
NS_IMPL_CYCLE_COLLECTION_CLASS(nsAbRDFDataSource)
NS_IMPL_CYCLE_COLLECTION_UNLINK_BEGIN(nsAbRDFDataSource)
NS_IMPL_CYCLE_COLLECTION_UNLINK_NSCOMARRAY(mObservers)
NS_IMPL_CYCLE_COLLECTION_UNLINK_NSCOMARRAY(mProxyObservers)
NS_IMPL_CYCLE_COLLECTION_UNLINK_END
NS_IMPL_CYCLE_COLLECTION_TRAVERSE_BEGIN(nsAbRDFDataSource)
NS_IMPL_CYCLE_COLLECTION_TRAVERSE_NSCOMARRAY(mObservers)
NS_IMPL_CYCLE_COLLECTION_UNLINK_NSCOMARRAY(mProxyObservers)
NS_IMPL_CYCLE_COLLECTION_TRAVERSE_END
NS_IMPL_CYCLE_COLLECTING_ADDREF_AMBIGUOUS(nsAbRDFDataSource, nsIRDFDataSource)
NS_IMPL_CYCLE_COLLECTING_RELEASE_AMBIGUOUS(nsAbRDFDataSource, nsIRDFDataSource)
NS_INTERFACE_MAP_BEGIN(nsAbRDFDataSource)
NS_INTERFACE_MAP_ENTRY(nsIRDFDataSource)
NS_INTERFACE_MAP_ENTRY_AMBIGUOUS(nsISupports, nsIRDFDataSource)
NS_INTERFACE_MAP_ENTRIES_CYCLE_COLLECTION(nsAbRDFDataSource)
NS_INTERFACE_MAP_END
// nsIRDFDataSource methods
NS_IMETHODIMP nsAbRDFDataSource::GetURI(char* *uri)
@@ -324,7 +311,7 @@ NS_IMETHODIMP nsAbRDFDataSource::GetSources(nsIRDFResource* property,
}
NS_IMETHODIMP nsAbRDFDataSource::GetTargets(nsIRDFResource* source,
nsIRDFResource* property,
nsIRDFResource* property,
PRBool tv,
nsISimpleEnumerator** targets)
{
@@ -332,7 +319,7 @@ NS_IMETHODIMP nsAbRDFDataSource::GetTargets(nsIRDFResource* source,
}
NS_IMETHODIMP nsAbRDFDataSource::Assert(nsIRDFResource* source,
nsIRDFResource* property,
nsIRDFResource* property,
nsIRDFNode* target,
PRBool tv)
{
@@ -375,85 +362,53 @@ NS_IMETHODIMP nsAbRDFDataSource::HasAssertion(nsIRDFResource* source,
NS_IMETHODIMP nsAbRDFDataSource::AddObserver(nsIRDFObserver* observer)
{
if(!mLock)
{
NS_ERROR("Error in AutoLock resource in nsAbRDFDataSource::AddObservers()");
return NS_ERROR_OUT_OF_MEMORY;
}
if(!mLock)
{
NS_ERROR("Error in AutoLock resource in nsAbRDFDataSource::AddObservers()");
return NS_ERROR_OUT_OF_MEMORY;
}
nsresult rv;
nsresult rv;
// Lock the whole method
nsAutoLock lockGuard (mLock);
// Lock the whole method
nsAutoLock lockGuard (mLock);
if (!mObservers)
{
rv = NS_NewISupportsArray(getter_AddRefs(mObservers));
NS_ENSURE_SUCCESS(rv, rv);
}
// Do not add if already present
if (mObservers.IndexOf(observer) >= 0)
return NS_OK;
// Do not add if already present
PRInt32 i;
mObservers->GetIndexOf (observer, &i);
if (i >= 0)
return NS_OK;
mObservers->AppendElement(observer);
/*
* If the proxy observers has been created
* then do the work here to avoid unecessary
* delay when performing the notify from a
* different thread
*/
if (mProxyObservers)
{
nsCOMPtr<nsIRDFObserver> proxyObserver;
rv = CreateProxyObserver (observer,
getter_AddRefs(proxyObserver));
NS_ENSURE_SUCCESS(rv, rv);
mProxyObservers->AppendElement (proxyObserver);
}
return NS_OK;
mObservers.AppendObject(observer);
return NS_OK;
}
NS_IMETHODIMP nsAbRDFDataSource::RemoveObserver(nsIRDFObserver* observer)
{
if(!mLock)
{
NS_ERROR("Error in AutoLock resource in nsAbRDFDataSource::RemoveObservers()");
return NS_ERROR_OUT_OF_MEMORY;
}
if(!mLock)
{
NS_ERROR("Error in AutoLock resource in nsAbRDFDataSource::RemoveObservers()");
return NS_ERROR_OUT_OF_MEMORY;
}
// Lock the whole method
nsAutoLock lockGuard (mLock);
// Lock the whole method
nsAutoLock lockGuard (mLock);
PRInt32 index = mObservers.IndexOf(observer);
if (index >= 0)
{
mObservers.RemoveObjectAt(index);
mProxyObservers.RemoveObjectAt(index);
}
if (!mObservers)
return NS_OK;
PRInt32 i;
mObservers->GetIndexOf (observer, &i);
if (i >= 0)
{
mObservers->RemoveElementAt(i);
if (mProxyObservers)
mProxyObservers->RemoveElementAt(i);
}
return NS_OK;
return NS_OK;
}
NS_IMETHODIMP
NS_IMETHODIMP
nsAbRDFDataSource::HasArcIn(nsIRDFNode *aNode, nsIRDFResource *aArc, PRBool *result)
{
*result = PR_FALSE;
return NS_OK;
}
NS_IMETHODIMP
NS_IMETHODIMP
nsAbRDFDataSource::HasArcOut(nsIRDFResource *aSource, nsIRDFResource *aArc, PRBool *result)
{
*result = PR_FALSE;

61
mozilla/mailnews/addrbook/src/nsAbRDFDataSource.h
View File

@@ -38,12 +38,12 @@
#ifndef nsAbRDFDataSource_h__
#define nsAbRDFDataSource_h__
#include "nsCOMPtr.h"
#include "nsIRDFDataSource.h"
#include "nsIRDFService.h"
#include "nsISupportsArray.h"
#include "nsCOMArray.h"
#include "nsString.h"
#include "nsCycleCollectionParticipant.h"
/**
* The addressbook data source.
@@ -51,45 +51,46 @@
class nsAbRDFDataSource : public nsIRDFDataSource
{
public:
NS_DECL_ISUPPORTS
NS_DECL_NSIRDFDATASOURCE
NS_DECL_CYCLE_COLLECTING_ISUPPORTS
NS_DECL_CYCLE_COLLECTION_CLASS_AMBIGUOUS(nsAbRDFDataSource,
nsIRDFDataSource)
NS_DECL_NSIRDFDATASOURCE
nsAbRDFDataSource();
virtual ~nsAbRDFDataSource();
nsAbRDFDataSource();
virtual ~nsAbRDFDataSource();
protected:
nsresult createNode(const PRUnichar *str, nsIRDFNode **node);
nsresult createNode(const PRUnichar *str, nsIRDFNode **node);
nsresult createBlobNode(PRUint8 *value, PRUint32 &length, nsIRDFNode **node, nsIRDFService *rdfService);
nsresult NotifyPropertyChanged(
nsIRDFResource *resource,
nsIRDFResource *propertyResource,
const PRUnichar *oldValue,
const PRUnichar *newValue);
nsresult NotifyPropertyChanged(
nsIRDFResource *resource,
nsIRDFResource *propertyResource,
const PRUnichar *oldValue,
const PRUnichar *newValue);
nsresult NotifyObservers(
nsIRDFResource *subject,
nsIRDFResource *property,
nsIRDFNode *object,
PRBool assert,
PRBool change);
nsresult NotifyObservers(
nsIRDFResource *subject,
nsIRDFResource *property,
nsIRDFNode *object,
PRBool assert,
PRBool change);
nsresult CreateProxyObservers ();
nsresult CreateProxyObservers ();
nsresult CreateProxyObserver (
nsIRDFObserver* observer,
nsIRDFObserver** proxyObserver);
nsresult CreateProxyObserver (
nsIRDFObserver* observer,
nsIRDFObserver** proxyObserver);
static PRBool assertEnumFunc(nsISupports *aElement, void *aData);
static PRBool unassertEnumFunc(nsISupports *aElement, void *aData);
static PRBool changeEnumFunc(nsISupports *aElement, void *aData);
static PRBool assertEnumFunc(nsIRDFObserver *aObserver, void *aData);
static PRBool unassertEnumFunc(nsIRDFObserver *aObserver, void *aData);
static PRBool changeEnumFunc(nsIRDFObserver *aObserver, void *aData);
private:
nsCOMPtr<nsISupportsArray> mObservers;
nsCOMPtr<nsISupportsArray> mProxyObservers;
PRLock* mLock;
nsCOMArray<nsIRDFObserver> mObservers;
nsCOMArray<nsIRDFObserver> mProxyObservers;
PRLock* mLock;
};
#endif

394
mozilla/mailnews/addrbook/src/nsDirectoryDataSource.cpp
View File

@@ -59,7 +59,7 @@
#include "prmem.h"
#include "nsServiceManagerUtils.h"
#include "nsCRT.h"
#define NC_RDF_DIRNAME "http://home.netscape.com/NC-rdf#DirName"
#define NC_RDF_DIRURI "http://home.netscape.com/NC-rdf#DirUri"
#define NC_RDF_ISMAILLIST "http://home.netscape.com/NC-rdf#IsMailList"
@@ -95,7 +95,7 @@ nsresult nsAbDirectoryDataSource::Cleanup()
rv = abSession->RemoveAddressBookListener(this);
NS_ENSURE_SUCCESS(rv,rv);
return NS_OK;
}
@@ -103,10 +103,10 @@ NS_IMETHODIMP
nsAbDirectoryDataSource::Observe(nsISupports *aSubject, const char *aTopic, const PRUnichar *someData)
{
if (!strcmp(aTopic,"profile-do-change")) {
/* the nsDirPrefs code caches all the directories that it got
/* the nsDirPrefs code caches all the directories that it got
* from the first profiles prefs.js
* When we profile switch, we need to force it to shut down.
* we'll re-load all the directories from the second profiles prefs.js
* we'll re-load all the directories from the second profiles prefs.js
* that happens in nsAbBSDirectory::GetChildNodes()
* when we call DIR_GetDirectories()
*/
@@ -124,20 +124,20 @@ nsresult
nsAbDirectoryDataSource::Init()
{
nsresult rv;
nsCOMPtr<nsIAddrBookSession> abSession =
do_GetService(NS_ADDRBOOKSESSION_CONTRACTID, &rv);
nsCOMPtr<nsIAddrBookSession> abSession =
do_GetService(NS_ADDRBOOKSESSION_CONTRACTID, &rv);
NS_ENSURE_SUCCESS(rv,rv);
// this listener cares about all events
rv = abSession->AddAddressBookListener(this, nsIAddrBookSession::all);
NS_ENSURE_SUCCESS(rv,rv);
nsCOMPtr <nsIRDFService> rdf = do_GetService("@mozilla.org/rdf/rdf-service;1", &rv);
NS_ENSURE_SUCCESS(rv,rv);
rv = rdf->RegisterDataSource(this, PR_FALSE);
NS_ENSURE_SUCCESS(rv,rv);
rv = rdf->GetResource(NS_LITERAL_CSTRING(NC_RDF_CHILD),
getter_AddRefs(kNC_Child));
NS_ENSURE_SUCCESS(rv,rv);
@@ -162,7 +162,7 @@ nsAbDirectoryDataSource::Init()
rv = rdf->GetResource(NS_LITERAL_CSTRING(NC_RDF_DIRTREENAMESORT), getter_AddRefs(kNC_DirTreeNameSort));
NS_ENSURE_SUCCESS(rv,rv);
rv = rdf->GetResource(NS_LITERAL_CSTRING(NC_RDF_DELETE),
getter_AddRefs(kNC_Delete));
getter_AddRefs(kNC_Delete));
NS_ENSURE_SUCCESS(rv,rv);
rv = rdf->GetResource(NS_LITERAL_CSTRING(NC_RDF_DELETECARDS),
getter_AddRefs(kNC_DeleteCards));
@@ -178,14 +178,14 @@ nsAbDirectoryDataSource::Init()
nsCOMPtr<nsIObserverService> observerService = do_GetService("@mozilla.org/observer-service;1", &rv);
NS_ENSURE_SUCCESS(rv,rv);
// since the observer (this) supports weak ref,
// since the observer (this) supports weak ref,
// and we call AddObserver() with PR_TRUE for ownsWeak
// we don't need to remove our observer from the from the observer service
rv = observerService->AddObserver(this, "profile-do-change", PR_TRUE);
NS_ENSURE_SUCCESS(rv,rv);
rv = observerService->AddObserver(this, NS_XPCOM_SHUTDOWN_OBSERVER_ID, PR_TRUE);
NS_ENSURE_SUCCESS(rv,rv);
return NS_OK;
}
@@ -220,13 +220,13 @@ NS_IMETHODIMP nsAbDirectoryDataSource::GetTarget(nsIRDFResource* source,
NS_IMETHODIMP nsAbDirectoryDataSource::GetTargets(nsIRDFResource* source,
nsIRDFResource* property,
nsIRDFResource* property,
PRBool tv,
nsISimpleEnumerator** targets)
{
nsresult rv = NS_RDF_NO_VALUE;
NS_ENSURE_ARG_POINTER(targets);
nsCOMPtr<nsIAbDirectory> directory(do_QueryInterface(source, &rv));
if (NS_SUCCEEDED(rv) && directory)
{
@@ -250,17 +250,17 @@ NS_IMETHODIMP nsAbDirectoryDataSource::GetTargets(nsIRDFResource* source,
}
NS_IMETHODIMP nsAbDirectoryDataSource::Assert(nsIRDFResource* source,
nsIRDFResource* property,
nsIRDFResource* property,
nsIRDFNode* target,
PRBool tv)
{
nsresult rv;
nsCOMPtr<nsIAbDirectory> directory(do_QueryInterface(source, &rv));
//We don't handle tv = PR_FALSE at the moment.
if(NS_SUCCEEDED(rv) && tv)
return DoDirectoryAssert(directory, property, target);
else
return NS_ERROR_FAILURE;
nsresult rv;
nsCOMPtr<nsIAbDirectory> directory(do_QueryInterface(source, &rv));
//We don't handle tv = PR_FALSE at the moment.
if(NS_SUCCEEDED(rv) && tv)
return DoDirectoryAssert(directory, property, target);
else
return NS_ERROR_FAILURE;
}
NS_IMETHODIMP nsAbDirectoryDataSource::HasAssertion(nsIRDFResource* source,
@@ -269,16 +269,16 @@ NS_IMETHODIMP nsAbDirectoryDataSource::HasAssertion(nsIRDFResource* source,
PRBool tv,
PRBool* hasAssertion)
{
nsresult rv;
nsCOMPtr<nsIAbDirectory> directory(do_QueryInterface(source, &rv));
if(NS_SUCCEEDED(rv))
return DoDirectoryHasAssertion(directory, property, target, tv, hasAssertion);
else
*hasAssertion = PR_FALSE;
return NS_OK;
nsresult rv;
nsCOMPtr<nsIAbDirectory> directory(do_QueryInterface(source, &rv));
if(NS_SUCCEEDED(rv))
return DoDirectoryHasAssertion(directory, property, target, tv, hasAssertion);
else
*hasAssertion = PR_FALSE;
return NS_OK;
}
NS_IMETHODIMP
NS_IMETHODIMP
nsAbDirectoryDataSource::HasArcOut(nsIRDFResource *aSource, nsIRDFResource *aArc, PRBool *result)
{
nsresult rv;
@@ -326,7 +326,7 @@ nsAbDirectoryDataSource::getDirectoryArcLabelsOut(nsIAbDirectory *directory,
nsresult rv;
rv = NS_NewISupportsArray(arcs);
NS_ENSURE_SUCCESS(rv, rv);
(*arcs)->AppendElement(kNC_DirName);
(*arcs)->AppendElement(kNC_Child);
(*arcs)->AppendElement(kNC_DirUri);
@@ -351,7 +351,7 @@ nsAbDirectoryDataSource::IsCommandEnabled(nsISupportsArray/*<nsIRDFResource>*/*
PRUint32 i, cnt;
rv = aSources->Count(&cnt);
for (i = 0; i < cnt; i++) {
directory = do_QueryElementAt(aSources, i, &rv);
directory = do_QueryElementAt(aSources, i, &rv);
if (NS_SUCCEEDED(rv)) {
// we don't care about the arguments -- directory commands are always enabled
if (!((aCommand == kNC_Delete) || (aCommand == kNC_DeleteCards))) {
@@ -369,86 +369,86 @@ nsAbDirectoryDataSource::DoCommand(nsISupportsArray/*<nsIRDFResource>*/* aSource
nsIRDFResource* aCommand,
nsISupportsArray/*<nsIRDFResource>*/* aArguments)
{
PRUint32 i, cnt;
nsresult rv = aSources->Count(&cnt);
NS_ENSURE_SUCCESS(rv, rv);
PRUint32 i, cnt;
nsresult rv = aSources->Count(&cnt);
NS_ENSURE_SUCCESS(rv, rv);
if ((aCommand == kNC_Delete))
rv = DoDeleteFromDirectory(aSources, aArguments);
if ((aCommand == kNC_Delete))
rv = DoDeleteFromDirectory(aSources, aArguments);
else {
for (i = 0; i < cnt; i++) {
nsCOMPtr<nsIAbDirectory> directory = do_QueryElementAt(aSources, i, &rv);
if (NS_SUCCEEDED(rv)) {
NS_ASSERTION(aCommand == kNC_DeleteCards, "unknown command");
if ((aCommand == kNC_DeleteCards))
if ((aCommand == kNC_DeleteCards))
rv = DoDeleteCardsFromDirectory(directory, aArguments);
}
}
}
//for the moment return NS_OK, because failure stops entire DoCommand process.
return NS_OK;
//for the moment return NS_OK, because failure stops entire DoCommand process.
return NS_OK;
}
NS_IMETHODIMP nsAbDirectoryDataSource::OnItemAdded(nsISupports *parentDirectory, nsISupports *item)
{
nsresult rv;
nsCOMPtr<nsIAbDirectory> directory;
nsCOMPtr<nsIRDFResource> parentResource;
nsresult rv;
nsCOMPtr<nsIAbDirectory> directory;
nsCOMPtr<nsIRDFResource> parentResource;
if(NS_SUCCEEDED(parentDirectory->QueryInterface(NS_GET_IID(nsIRDFResource), getter_AddRefs(parentResource))))
{
//If we are adding a directory
if (NS_SUCCEEDED(item->QueryInterface(NS_GET_IID(nsIAbDirectory), getter_AddRefs(directory))))
{
nsCOMPtr<nsIRDFNode> itemNode(do_QueryInterface(item, &rv));
if(NS_SUCCEEDED(rv))
{
//Notify a directory was added.
NotifyObservers(parentResource, kNC_Child, itemNode, PR_TRUE, PR_FALSE);
}
}
}
if(NS_SUCCEEDED(parentDirectory->QueryInterface(NS_GET_IID(nsIRDFResource), getter_AddRefs(parentResource))))
{
//If we are adding a directory
if (NS_SUCCEEDED(item->QueryInterface(NS_GET_IID(nsIAbDirectory), getter_AddRefs(directory))))
{
nsCOMPtr<nsIRDFNode> itemNode(do_QueryInterface(item, &rv));
if(NS_SUCCEEDED(rv))
{
//Notify a directory was added.
NotifyObservers(parentResource, kNC_Child, itemNode, PR_TRUE, PR_FALSE);
}
}
}
return NS_OK;
return NS_OK;
}
NS_IMETHODIMP nsAbDirectoryDataSource::OnItemRemoved(nsISupports *parentDirectory, nsISupports *item)
{
nsresult rv;
nsCOMPtr<nsIAbDirectory> directory;
nsCOMPtr<nsIRDFResource> parentResource;
nsresult rv;
nsCOMPtr<nsIAbDirectory> directory;
nsCOMPtr<nsIRDFResource> parentResource;
if(NS_SUCCEEDED(parentDirectory->QueryInterface(NS_GET_IID(nsIRDFResource), getter_AddRefs(parentResource))))
{
//If we are removing a directory
if (NS_SUCCEEDED(item->QueryInterface(NS_GET_IID(nsIAbDirectory), getter_AddRefs(directory))))
{
nsCOMPtr<nsIRDFNode> itemNode(do_QueryInterface(item, &rv));
if(NS_SUCCEEDED(rv))
{
//Notify a directory was deleted.
NotifyObservers(parentResource, kNC_Child, itemNode, PR_FALSE, PR_FALSE);
}
}
}
return NS_OK;
if(NS_SUCCEEDED(parentDirectory->QueryInterface(NS_GET_IID(nsIRDFResource), getter_AddRefs(parentResource))))
{
//If we are removing a directory
if (NS_SUCCEEDED(item->QueryInterface(NS_GET_IID(nsIAbDirectory), getter_AddRefs(directory))))
{
nsCOMPtr<nsIRDFNode> itemNode(do_QueryInterface(item, &rv));
if(NS_SUCCEEDED(rv))
{
//Notify a directory was deleted.
NotifyObservers(parentResource, kNC_Child, itemNode, PR_FALSE, PR_FALSE);
}
}
}
return NS_OK;
}
NS_IMETHODIMP nsAbDirectoryDataSource::OnItemPropertyChanged(nsISupports *item, const char *property,
const PRUnichar *oldValue, const PRUnichar *newValue)
const PRUnichar *oldValue, const PRUnichar *newValue)
{
nsresult rv;
nsCOMPtr<nsIRDFResource> resource(do_QueryInterface(item, &rv));
nsresult rv;
nsCOMPtr<nsIRDFResource> resource(do_QueryInterface(item, &rv));
if(NS_SUCCEEDED(rv))
{
if(PL_strcmp("DirName", property) == 0)
{
NotifyPropertyChanged(resource, kNC_DirName, oldValue, newValue);
}
}
return NS_OK;
if(NS_SUCCEEDED(rv))
{
if(PL_strcmp("DirName", property) == 0)
{
NotifyPropertyChanged(resource, kNC_DirName, oldValue, newValue);
}
}
return NS_OK;
}
nsresult nsAbDirectoryDataSource::createDirectoryNode(nsIAbDirectory* directory,
@@ -456,21 +456,21 @@ nsresult nsAbDirectoryDataSource::createDirectoryNode(nsIAbDirectory* directory,
nsIRDFNode** target)
{
nsresult rv = NS_RDF_NO_VALUE;
if ((kNC_DirName == property))
rv = createDirectoryNameNode(directory, target);
rv = createDirectoryNameNode(directory, target);
else if ((kNC_DirUri == property))
rv = createDirectoryUriNode(directory, target);
rv = createDirectoryUriNode(directory, target);
else if ((kNC_Child == property))
rv = createDirectoryChildNode(directory, target);
rv = createDirectoryChildNode(directory, target);
else if ((kNC_IsMailList == property))
rv = createDirectoryIsMailListNode(directory, target);
rv = createDirectoryIsMailListNode(directory, target);
else if ((kNC_IsRemote == property))
rv = createDirectoryIsRemoteNode(directory, target);
rv = createDirectoryIsRemoteNode(directory, target);
else if ((kNC_IsSecure == property))
rv = createDirectoryIsSecureNode(directory, target);
rv = createDirectoryIsSecureNode(directory, target);
else if ((kNC_IsWriteable == property))
rv = createDirectoryIsWriteableNode(directory, target);
rv = createDirectoryIsWriteableNode(directory, target);
else if ((kNC_DirTreeNameSort == property))
rv = createDirectoryTreeNameSortNode(directory, target);
else if ((kNC_SupportsMailingLists == property))
@@ -509,27 +509,27 @@ nsresult
nsAbDirectoryDataSource::createDirectoryChildNode(nsIAbDirectory *directory,
nsIRDFNode **target)
{
nsCOMPtr<nsISupportsArray> pAddressLists;
directory->GetAddressLists(getter_AddRefs(pAddressLists));
nsCOMPtr<nsISupportsArray> pAddressLists;
directory->GetAddressLists(getter_AddRefs(pAddressLists));
if (pAddressLists)
{
PRUint32 total = 0;
pAddressLists->Count(&total);
if (pAddressLists)
{
PRUint32 total = 0;
pAddressLists->Count(&total);
if (total)
{
PRBool isMailList = PR_FALSE;
directory->GetIsMailList(&isMailList);
if (!isMailList)
if (total)
{
PRBool isMailList = PR_FALSE;
directory->GetIsMailList(&isMailList);
if (!isMailList)
{
// fetch the last element
// fetch the last element
nsCOMPtr<nsIRDFResource> mailList = do_QueryElementAt(pAddressLists, total - 1);
NS_IF_ADDREF(*target = mailList);
}
}
} // if total
} // if pAddressLists
return (*target ? NS_OK : NS_RDF_NO_VALUE);
}
@@ -540,7 +540,7 @@ nsAbDirectoryDataSource::createDirectoryIsRemoteNode(nsIAbDirectory* directory,
PRBool isRemote;
nsresult rv = directory->GetIsRemote(&isRemote);
NS_ENSURE_SUCCESS(rv, rv);
NS_IF_ADDREF(*target = (isRemote ? kTrueLiteral : kFalseLiteral));
return NS_OK;
}
@@ -552,7 +552,7 @@ nsAbDirectoryDataSource::createDirectoryIsSecureNode(nsIAbDirectory* directory,
PRBool IsSecure;
nsresult rv = directory->GetIsSecure(&IsSecure);
NS_ENSURE_SUCCESS(rv, rv);
NS_IF_ADDREF(*target = (IsSecure ? kTrueLiteral : kFalseLiteral));
return NS_OK;
}
@@ -564,7 +564,7 @@ nsAbDirectoryDataSource::createDirectoryIsWriteableNode(nsIAbDirectory* director
PRBool isWriteable;
nsresult rv = directory->GetOperations(&isWriteable);
NS_ENSURE_SUCCESS(rv, rv);
NS_IF_ADDREF(*target = ((isWriteable & nsIAbDirectory::opWrite) ? kTrueLiteral : kFalseLiteral));
return NS_OK;
}
@@ -576,7 +576,7 @@ nsAbDirectoryDataSource::createDirectoryIsMailListNode(nsIAbDirectory* directory
PRBool isMailList;
nsresult rv = directory->GetIsMailList(&isMailList);
NS_ENSURE_SUCCESS(rv, rv);
NS_IF_ADDREF(*target = (isMailList ? kTrueLiteral : kFalseLiteral));
return NS_OK;
}
@@ -598,7 +598,7 @@ nsAbDirectoryDataSource::createDirectoryTreeNameSortNode(nsIAbDirectory* directo
{
nsString name;
nsresult rv = directory->GetDirName(name);
NS_ENSURE_SUCCESS(rv, rv);
NS_ENSURE_SUCCESS(rv, rv);
/* sort addressbooks in this order - Personal Addressbook, Collected Addresses, MDB, LDAP -
* by prefixing address book names with numbers and using the xul sort service.
@@ -654,7 +654,7 @@ nsAbDirectoryDataSource::createDirectoryTreeNameSortNode(nsIAbDirectory* directo
else if (strcmp(uri, kCollectedAddressbookUri) == 0)
sortString.AppendInt(1); // Collected addrbook
else
sortString.AppendInt(2); // Normal addrbook
sortString.AppendInt(2); // Normal addrbook
}
else if (dirType == LDAPDirectory)
sortString.AppendInt(3); // LDAP addrbook
@@ -687,14 +687,14 @@ nsresult nsAbDirectoryDataSource::CreateCollationKey(const nsString &aSource, P
nsresult rv;
if (!mCollationKeyGenerator)
{
nsCOMPtr<nsILocaleService> localeSvc = do_GetService(NS_LOCALESERVICE_CONTRACTID,&rv);
nsCOMPtr<nsILocaleService> localeSvc = do_GetService(NS_LOCALESERVICE_CONTRACTID,&rv);
NS_ENSURE_SUCCESS(rv, rv);
nsCOMPtr<nsILocale> locale;
nsCOMPtr<nsILocale> locale;
rv = localeSvc->GetApplicationLocale(getter_AddRefs(locale));
NS_ENSURE_SUCCESS(rv, rv);
nsCOMPtr <nsICollationFactory> factory = do_CreateInstance(NS_COLLATIONFACTORY_CONTRACTID, &rv);
nsCOMPtr <nsICollationFactory> factory = do_CreateInstance(NS_COLLATIONFACTORY_CONTRACTID, &rv);
NS_ENSURE_SUCCESS(rv, rv);
rv = factory->CreateCollation(locale, getter_AddRefs(mCollationKeyGenerator));
@@ -706,119 +706,119 @@ nsresult nsAbDirectoryDataSource::CreateCollationKey(const nsString &aSource, P
nsresult nsAbDirectoryDataSource::DoDeleteFromDirectory(nsISupportsArray *parentDirs, nsISupportsArray *delDirs)
{
PRUint32 item, itemCount;
nsresult rv = parentDirs->Count(&itemCount);
NS_ENSURE_SUCCESS(rv, rv);
PRUint32 item, itemCount;
nsresult rv = parentDirs->Count(&itemCount);
NS_ENSURE_SUCCESS(rv, rv);
for (item = 0; item < itemCount; item++)
{
nsCOMPtr<nsIAbDirectory> parent = do_QueryElementAt(parentDirs, item, &rv);
if (NS_SUCCEEDED(rv))
{
nsCOMPtr<nsIAbDirectory> deletedDir(do_QueryElementAt(delDirs, item));
if(deletedDir)
{
rv = parent->DeleteDirectory(deletedDir);
}
}
}
return rv;
for (item = 0; item < itemCount; item++)
{
nsCOMPtr<nsIAbDirectory> parent = do_QueryElementAt(parentDirs, item, &rv);
if (NS_SUCCEEDED(rv))
{
nsCOMPtr<nsIAbDirectory> deletedDir(do_QueryElementAt(delDirs, item));
if(deletedDir)
{
rv = parent->DeleteDirectory(deletedDir);
}
}
}
return rv;
}
nsresult nsAbDirectoryDataSource::DoDeleteCardsFromDirectory(nsIAbDirectory *directory, nsISupportsArray *arguments)
{
nsresult rv = NS_OK;
PRUint32 itemCount;
rv = arguments->Count(&itemCount);
NS_ENSURE_SUCCESS(rv, rv);
nsCOMPtr<nsISupportsArray> cardArray;
NS_NewISupportsArray(getter_AddRefs(cardArray));
nsresult rv = NS_OK;
PRUint32 itemCount;
rv = arguments->Count(&itemCount);
NS_ENSURE_SUCCESS(rv, rv);
//Split up deleted items into different type arrays to be passed to the folder
//for deletion.
PRUint32 item;
for(item = 0; item < itemCount; item++)
{
nsCOMPtr<nsISupportsArray> cardArray;
NS_NewISupportsArray(getter_AddRefs(cardArray));
//Split up deleted items into different type arrays to be passed to the folder
//for deletion.
PRUint32 item;
for(item = 0; item < itemCount; item++)
{
nsCOMPtr<nsIAbCard> deletedCard(do_QueryElementAt(arguments, item));
if (deletedCard)
{
if (deletedCard)
{
rv = cardArray->AppendElement(deletedCard);
NS_ENSURE_SUCCESS(rv, rv);
}
}
PRUint32 cnt;
rv = cardArray->Count(&cnt);
NS_ENSURE_SUCCESS(rv, rv);
if (cnt > 0)
rv = directory->DeleteCards(cardArray);
return rv;
}
}
PRUint32 cnt;
rv = cardArray->Count(&cnt);
NS_ENSURE_SUCCESS(rv, rv);
if (cnt > 0)
rv = directory->DeleteCards(cardArray);
return rv;
}
nsresult nsAbDirectoryDataSource::DoDirectoryAssert(nsIAbDirectory *directory, nsIRDFResource *property, nsIRDFNode *target)
{
nsresult rv = NS_ERROR_FAILURE;
return rv;
nsresult rv = NS_ERROR_FAILURE;
return rv;
}
nsresult nsAbDirectoryDataSource::DoDirectoryHasAssertion(nsIAbDirectory *directory, nsIRDFResource *property, nsIRDFNode *target,
PRBool tv, PRBool *hasAssertion)
PRBool tv, PRBool *hasAssertion)
{
nsresult rv = NS_OK;
if (!hasAssertion)
return NS_ERROR_NULL_POINTER;
nsresult rv = NS_OK;
if (!hasAssertion)
return NS_ERROR_NULL_POINTER;
//We're not keeping track of negative assertions on directory.
if (!tv)
{
*hasAssertion = PR_FALSE;
return NS_OK;
}
//We're not keeping track of negative assertions on directory.
if (!tv)
{
*hasAssertion = PR_FALSE;
return NS_OK;
}
if ((kNC_Child == property))
{
nsCOMPtr<nsIAbDirectory> newDirectory(do_QueryInterface(target, &rv));
if(NS_SUCCEEDED(rv))
rv = directory->HasDirectory(newDirectory, hasAssertion);
}
else if ((kNC_IsMailList == property) || (kNC_IsRemote == property) ||
{
nsCOMPtr<nsIAbDirectory> newDirectory(do_QueryInterface(target, &rv));
if(NS_SUCCEEDED(rv))
rv = directory->HasDirectory(newDirectory, hasAssertion);
}
else if ((kNC_IsMailList == property) || (kNC_IsRemote == property) ||
(kNC_IsSecure == property) || (kNC_IsWriteable == property) ||
(kNC_SupportsMailingLists == property))
{
nsCOMPtr<nsIRDFResource> dirResource(do_QueryInterface(directory, &rv));
NS_ENSURE_SUCCESS(rv, rv);
rv = GetTargetHasAssertion(this, dirResource, property, tv, target, hasAssertion);
}
else
*hasAssertion = PR_FALSE;
{
nsCOMPtr<nsIRDFResource> dirResource(do_QueryInterface(directory, &rv));
NS_ENSURE_SUCCESS(rv, rv);
rv = GetTargetHasAssertion(this, dirResource, property, tv, target, hasAssertion);
}
else
*hasAssertion = PR_FALSE;
return rv;
return rv;
}
nsresult nsAbDirectoryDataSource::GetTargetHasAssertion(nsIRDFDataSource *dataSource, nsIRDFResource* dirResource,
nsIRDFResource *property,PRBool tv, nsIRDFNode *target,PRBool* hasAssertion)
nsIRDFResource *property,PRBool tv, nsIRDFNode *target,PRBool* hasAssertion)
{
nsresult rv;
if(!hasAssertion)
return NS_ERROR_NULL_POINTER;
nsresult rv;
if(!hasAssertion)
return NS_ERROR_NULL_POINTER;
nsCOMPtr<nsIRDFNode> currentTarget;
nsCOMPtr<nsIRDFNode> currentTarget;
rv = dataSource->GetTarget(dirResource, property,tv, getter_AddRefs(currentTarget));
if(NS_SUCCEEDED(rv))
{
nsCOMPtr<nsIRDFLiteral> value1(do_QueryInterface(target));
nsCOMPtr<nsIRDFLiteral> value2(do_QueryInterface(currentTarget));
if(value1 && value2)
//If the two values are equal then it has this assertion
*hasAssertion = (value1 == value2);
}
else
rv = NS_NOINTERFACE;
rv = dataSource->GetTarget(dirResource, property,tv, getter_AddRefs(currentTarget));
if(NS_SUCCEEDED(rv))
{
nsCOMPtr<nsIRDFLiteral> value1(do_QueryInterface(target));
nsCOMPtr<nsIRDFLiteral> value2(do_QueryInterface(currentTarget));
if(value1 && value2)
//If the two values are equal then it has this assertion
*hasAssertion = (value1 == value2);
}
else
rv = NS_NOINTERFACE;
return rv;
return rv;
}

108
mozilla/mailnews/addrbook/src/nsDirectoryDataSource.h
View File

@@ -54,97 +54,97 @@
* The addressbook data source.
*/
class nsAbDirectoryDataSource : public nsAbRDFDataSource,
public nsIAbListener, public nsIObserver, public nsSupportsWeakReference
public nsIAbListener, public nsIObserver, public nsSupportsWeakReference
{
private:
PRBool mInitialized;
PRBool mInitialized;
public:
NS_DECL_ISUPPORTS_INHERITED
NS_DECL_ISUPPORTS_INHERITED
NS_DECL_NSIABLISTENER
NS_DECL_NSIOBSERVER
nsAbDirectoryDataSource(void);
virtual ~nsAbDirectoryDataSource (void);
virtual nsresult Init();
nsAbDirectoryDataSource(void);
virtual ~nsAbDirectoryDataSource (void);
virtual nsresult Init();
// nsIRDFDataSource methods
NS_IMETHOD GetURI(char* *uri);
// nsIRDFDataSource methods
NS_IMETHOD GetURI(char* *uri);
NS_IMETHOD GetTarget(nsIRDFResource* source,
nsIRDFResource* property,
PRBool tv,
nsIRDFNode** target);
NS_IMETHOD GetTarget(nsIRDFResource* source,
nsIRDFResource* property,
PRBool tv,
nsIRDFNode** target);
NS_IMETHOD GetTargets(nsIRDFResource* source,
nsIRDFResource* property,
PRBool tv,
nsISimpleEnumerator** targets);
NS_IMETHOD GetTargets(nsIRDFResource* source,
nsIRDFResource* property,
PRBool tv,
nsISimpleEnumerator** targets);
NS_IMETHOD Assert(nsIRDFResource* source,
nsIRDFResource* property,
nsIRDFNode* target,
PRBool tv);
NS_IMETHOD Assert(nsIRDFResource* source,
nsIRDFResource* property,
nsIRDFNode* target,
PRBool tv);
NS_IMETHOD HasAssertion(nsIRDFResource* source,
nsIRDFResource* property,
nsIRDFNode* target,
PRBool tv,
PRBool* hasAssertion);
NS_IMETHOD HasAssertion(nsIRDFResource* source,
nsIRDFResource* property,
nsIRDFNode* target,
PRBool tv,
PRBool* hasAssertion);
NS_IMETHOD HasArcOut(nsIRDFResource *aSource, nsIRDFResource *aArc, PRBool *result);
NS_IMETHOD HasArcOut(nsIRDFResource *aSource, nsIRDFResource *aArc, PRBool *result);
NS_IMETHOD ArcLabelsOut(nsIRDFResource* source,
nsISimpleEnumerator** labels);
NS_IMETHOD ArcLabelsOut(nsIRDFResource* source,
nsISimpleEnumerator** labels);
NS_IMETHOD IsCommandEnabled(nsISupportsArray/*<nsIRDFResource>*/* aSources,
nsIRDFResource* aCommand,
nsISupportsArray/*<nsIRDFResource>*/* aArguments,
PRBool* aResult);
NS_IMETHOD IsCommandEnabled(nsISupportsArray/*<nsIRDFResource>*/* aSources,
nsIRDFResource* aCommand,
nsISupportsArray/*<nsIRDFResource>*/* aArguments,
PRBool* aResult);
NS_IMETHOD DoCommand(nsISupportsArray/*<nsIRDFResource>*/* aSources,
nsIRDFResource* aCommand,
nsISupportsArray/*<nsIRDFResource>*/* aArguments);
NS_IMETHOD DoCommand(nsISupportsArray/*<nsIRDFResource>*/* aSources,
nsIRDFResource* aCommand,
nsISupportsArray/*<nsIRDFResource>*/* aArguments);
protected:
nsresult createDirectoryNode(nsIAbDirectory* directory, nsIRDFResource* property,
nsresult createDirectoryNode(nsIAbDirectory* directory, nsIRDFResource* property,
nsIRDFNode** target);
nsresult createDirectoryNameNode(nsIAbDirectory *directory,
nsresult createDirectoryNameNode(nsIAbDirectory *directory,
nsIRDFNode **target);
nsresult createDirectoryUriNode(nsIAbDirectory *directory,
nsresult createDirectoryUriNode(nsIAbDirectory *directory,
nsIRDFNode **target);
nsresult createDirectoryChildNode(nsIAbDirectory *directory,
nsresult createDirectoryChildNode(nsIAbDirectory *directory,
nsIRDFNode **target);
nsresult createDirectoryIsMailListNode(nsIAbDirectory *directory,
nsresult createDirectoryIsMailListNode(nsIAbDirectory *directory,
nsIRDFNode **target);
nsresult createDirectoryIsRemoteNode(nsIAbDirectory *directory,
nsIRDFNode **target);
nsresult createDirectoryIsSecureNode(nsIAbDirectory *directory,
nsIRDFNode **target);
nsresult createDirectoryIsWriteableNode(nsIAbDirectory *directory,
nsresult createDirectoryIsWriteableNode(nsIAbDirectory *directory,
nsIRDFNode **target);
nsresult createDirectorySupportsMailingListsNode(nsIAbDirectory* directory,
nsIRDFNode **target);
nsresult createDirectoryTreeNameSortNode(nsIAbDirectory *directory,
nsIRDFNode **target);
nsresult getDirectoryArcLabelsOut(nsIAbDirectory *directory,
nsISupportsArray **arcs);
nsresult getDirectoryArcLabelsOut(nsIAbDirectory *directory,
nsISupportsArray **arcs);
nsresult DoDeleteFromDirectory(nsISupportsArray *parentDirs,
nsISupportsArray *delDirs);
nsresult DoDeleteCardsFromDirectory(nsIAbDirectory *directory,
nsISupportsArray *delDirs);
nsresult DoDeleteFromDirectory(nsISupportsArray *parentDirs,
nsISupportsArray *delDirs);
nsresult DoDeleteCardsFromDirectory(nsIAbDirectory *directory,
nsISupportsArray *delDirs);
nsresult DoDirectoryAssert(nsIAbDirectory *directory,
nsIRDFResource *property, nsIRDFNode *target);
nsresult DoDirectoryHasAssertion(nsIAbDirectory *directory,
nsIRDFResource *property, nsIRDFNode *target,
PRBool tv, PRBool *hasAssertion);
nsresult DoDirectoryAssert(nsIAbDirectory *directory,
nsIRDFResource *property, nsIRDFNode *target);
nsresult DoDirectoryHasAssertion(nsIAbDirectory *directory,
nsIRDFResource *property, nsIRDFNode *target,
PRBool tv, PRBool *hasAssertion);
nsresult GetTargetHasAssertion(nsIRDFDataSource *dataSource, nsIRDFResource* dirResource,
nsIRDFResource *property,PRBool tv, nsIRDFNode *target,PRBool* hasAssertion);
nsresult GetTargetHasAssertion(nsIRDFDataSource *dataSource, nsIRDFResource* dirResource,
nsIRDFResource *property,PRBool tv, nsIRDFNode *target,PRBool* hasAssertion);
nsresult CreateCollationKey(const nsString &aSource, PRUint8 **aKey, PRUint32 *aLength);
nsCOMPtr<nsIRDFResource> kNC_Child;