* The exists method can be used to determine whether the
* folder actually exists.
*
* In some Stores, name can be an absolute path if it starts
* with the hierarchy delimiter. Otherwise it is interpreted relative
* to the root of this namespace.
* @param name the folder name
* @exception IllegalStateException if the store is not connected
*/
public abstract Folder getFolder(String name)
throws MessagingException;
/**
* Returns the folder corresponding to the given URLName.
* @param url a URLName denoting a folder
* @exception IllegalStateException if this store is not connected
*/
public abstract Folder getFolder(URLName url)
throws MessagingException;
/**
* Returns the personal namespaces for the authenticated user.
*/
public Folder[] getPersonalNamespaces()
throws MessagingException
{
Folder[] folders = new Folder[1];
folders[0] = getDefaultFolder();
return folders;
}
/**
* Returns the personal namespaces for the specified user.
*/
public Folder[] getUserNamespaces(String user)
throws MessagingException
{
return new Folder[0];
}
/**
* Returns the shared namespaces.
*/
public Folder[] getSharedNamespaces()
throws MessagingException
{
return new Folder[0];
}
// -- Event management --
/*
* Because the propagation of events of different kinds in the JavaMail
* API is so haphazard, I have here sacrificed a small time advantage for
* readability and consistency.
*
* All the various propagation methods now call a method with a name based
* on the eventual listener method name prefixed by 'fire', as is the
* preferred pattern for usage of the EventListenerList in Swing.
*
* Note that all events are currently delivered synchronously, where in
* Sun's implementation a different thread is used for event delivery.
*
* TODO Examine the impact of this.
*/
// -- Store events --
/**
* Adds a listener for store events on this store.
*/
public void addStoreListener(StoreListener l)
{
if (storeListeners == null)
{
storeListeners = new ArrayList();
}
synchronized (storeListeners)
{
storeListeners.add(l);
}
}
/**
* Removes a store events listener.
*/
public void removeStoreListener(StoreListener l)
{
if (storeListeners != null)
{
synchronized (storeListeners)
{
storeListeners.remove(l);
}
}
}
/**
* Notifies all store event listeners.
*/
protected void notifyStoreListeners(int type, String message)
{
StoreEvent event = new StoreEvent(this, type, message);
fireNotification(event);
}
/*
* Propagates a StoreEvent to all registered listeners.
*/
void fireNotification(StoreEvent event)
{
if (storeListeners != null)
{
StoreListener[] l = null;
synchronized (storeListeners)
{
l = new StoreListener[storeListeners.size()];
storeListeners.toArray(l);
}
for (int i = 0; i < l.length; i++)
{
l[i].notification(event);
}
}
}
// -- Folder events --
/**
* Adds a listener for folder events on any folder object obtained from this
* store.
*/
public void addFolderListener(FolderListener l)
{
if (folderListeners == null)
{
folderListeners = new ArrayList();
}
synchronized (folderListeners)
{
folderListeners.add(l);
}
}
/**
* Removes a folder event listener.
*/
public void removeFolderListener(FolderListener l)
{
if (folderListeners != null)
{
synchronized (folderListeners)
{
folderListeners.remove(l);
}
}
}
/**
* Notifies all folder listeners.
*/
protected void notifyFolderListeners(int type, Folder folder)
{
FolderEvent event = new FolderEvent(this, folder, type);
switch (type)
{
case FolderEvent.CREATED:
fireFolderCreated(event);
break;
case FolderEvent.DELETED:
fireFolderDeleted(event);
break;
}
}
/**
* Notifies all folder listeners about the renaming of a folder.
*/
protected void notifyFolderRenamedListeners(Folder oldFolder,
Folder newFolder)
{
FolderEvent event = new FolderEvent(this, oldFolder, newFolder,
FolderEvent.RENAMED);
fireFolderRenamed(event);
}
/*
* Propagates a CREATED FolderEvent to all registered listeners.
*/
void fireFolderCreated(FolderEvent event)
{
if (folderListeners != null)
{
FolderListener[] l = null;
synchronized (folderListeners)
{
l = new FolderListener[folderListeners.size()];
folderListeners.toArray(l);
}
for (int i = 0; i < l.length; i++)
{
l[i].folderCreated(event);
}
}
}
/*
* Propagates a DELETED FolderEvent to all registered listeners.
*/
void fireFolderDeleted(FolderEvent event)
{
if (folderListeners != null)
{
FolderListener[] l = null;
synchronized (folderListeners)
{
l = new FolderListener[folderListeners.size()];
folderListeners.toArray(l);
}
for (int i = 0; i < l.length; i++)
{
l[i].folderDeleted(event);
}
}
}
/*
* Propagates a RENAMED FolderEvent to all registered listeners.
*/
void fireFolderRenamed(FolderEvent event)
{
if (folderListeners != null)
{
FolderListener[] l = null;
synchronized (folderListeners)
{
l = new FolderListener[folderListeners.size()];
folderListeners.toArray(l);
}
for (int i = 0; i < l.length; i++)
{
l[i].folderRenamed(event);
}
}
}
}