/**
* Returns the total number of groups in the system.
*
* @return the total number of groups.
*/
public int getGroupCount() {
Integer count = (Integer) groupMetaCache.get(GROUP_COUNT_KEY);
if (count == null) {
synchronized (GROUP_COUNT_KEY.intern()) {
count = (Integer) groupMetaCache.get(GROUP_COUNT_KEY);
if (count == null) {
count = provider.getGroupCount();
groupMetaCache.put(GROUP_COUNT_KEY, count);
}
}
}
return count;
}
/**
* Deletes a group from the system.
*
* @param group the group to delete.
*/
public void deleteGroup(Group group) {
Map<String, Object> emptyMap = new HashMap<String, Object>();
// Fire event.
GroupEventDispatcher.dispatchEvent(
group, GroupEventDispatcher.EventType.group_deleting, emptyMap);
// Delete the group.
provider.deleteGroup(group.getName());
// Expire cache.
groupCache.remove(group.getName());
}
/**
* Returns an unmodifiable Collection of all shared groups in the system.
*
* @return an unmodifiable Collection of all shared groups.
*/
@SuppressWarnings("unchecked")
public Collection<Group> getSharedGroups() {
Collection<String> groupNames = (Collection<String>) groupMetaCache.get(SHARED_GROUPS_KEY);
if (groupNames == null) {
synchronized (SHARED_GROUPS_KEY.intern()) {
groupNames = (Collection<String>) groupMetaCache.get(SHARED_GROUPS_KEY);
if (groupNames == null) {
groupNames = provider.getSharedGroupsNames();
groupMetaCache.put(SHARED_GROUPS_KEY, groupNames);
}
}
}
return new GroupCollection(groupNames);
}
/**
* Returns an iterator for all groups that the entity with the specified JID is a member of.
*
* @param user the JID of the entity to get a list of groups for.
* @return all groups that an entity belongs to.
*/
@SuppressWarnings("unchecked")
public Collection<Group> getGroups(JID user) {
String key = user.toBareJID();
Collection<String> groupNames = (Collection<String>) groupMetaCache.get(key);
if (groupNames == null) {
synchronized (key.intern()) {
groupNames = (Collection<String>) groupMetaCache.get(key);
if (groupNames == null) {
groupNames = provider.getGroupNames(user);
groupMetaCache.put(key, groupNames);
}
}
}
return new GroupCollection(groupNames);
}
/**
* Returns all groups given a start index and desired number of results. This is useful to support
* pagination in a GUI where you may only want to display a certain number of results per page. It
* is possible that the number of results returned will be less than that specified by numResults
* if numResults is greater than the number of records left in the system to display.
*
* @param startIndex start index in results.
* @param numResults number of results to return.
* @return an Iterator for all groups in the specified range.
*/
@SuppressWarnings("unchecked")
public Collection<Group> getGroups(int startIndex, int numResults) {
String key = GROUP_NAMES_KEY + startIndex + "," + numResults;
Collection<String> groupNames = (Collection<String>) groupMetaCache.get(key);
if (groupNames == null) {
synchronized (key.intern()) {
groupNames = (Collection<String>) groupMetaCache.get(key);
if (groupNames == null) {
groupNames = provider.getGroupNames(startIndex, numResults);
groupMetaCache.put(key, groupNames);
}
}
}
return new GroupCollection(groupNames);
}
/**
* Returns a Group by name.
*
* @param name The name of the group to retrieve
* @return The group corresponding to that name
* @throws GroupNotFoundException if the group does not exist.
*/
public Group getGroup(String name, boolean forceLookup) throws GroupNotFoundException {
Group group = null;
if (!forceLookup) {
group = groupCache.get(name);
}
// If ID wan't found in cache, load it up and put it there.
if (group == null) {
synchronized (name.intern()) {
group = groupCache.get(name);
// If group wan't found in cache, load it up and put it there.
if (group == null) {
group = provider.getGroup(name);
groupCache.put(name, group);
}
}
}
return group;
}
/**
* Factory method for creating a new Group. A unique name is the only required field.
*
* @param name the new and unique name for the group.
* @return a new Group.
* @throws GroupAlreadyExistsException if the group name already exists in the system.
*/
public Group createGroup(String name) throws GroupAlreadyExistsException {
synchronized (name.intern()) {
Group newGroup;
try {
getGroup(name);
// The group already exists since now exception, so:
throw new GroupAlreadyExistsException();
} catch (GroupNotFoundException unfe) {
// The group doesn't already exist so we can create a new group
newGroup = provider.createGroup(name);
// Update caches.
groupCache.put(name, newGroup);
Map<String, Object> emptyMap = new HashMap<String, Object>();
// Fire event.
GroupEventDispatcher.dispatchEvent(
newGroup, GroupEventDispatcher.EventType.group_created, emptyMap);
}
return newGroup;
}
}
/**
* Returns the groups that match the search given a start index and desired number of results. The
* search is over group names and implicitly uses wildcard matching (although the exact search
* semantics are left up to each provider implementation). For example, a search for "HR" should
* match the groups "HR", "HR Department", and "The HR People".
*
* <p>Before searching or showing a search UI, use the {@link #isSearchSupported} method to ensure
* that searching is supported.
*
* @param query the search string for group names.
* @return all groups that match the search.
*/
public Collection<Group> search(String query, int startIndex, int numResults) {
Collection<String> groupNames = provider.search(query, startIndex, numResults);
return new GroupCollection(groupNames);
}
/**
* Returns the groups that match the search. The search is over group names and implicitly uses
* wildcard matching (although the exact search semantics are left up to each provider
* implementation). For example, a search for "HR" should match the groups "HR", "HR Department",
* and "The HR People".
*
* <p>Before searching or showing a search UI, use the {@link #isSearchSupported} method to ensure
* that searching is supported.
*
* @param query the search string for group names.
* @return all groups that match the search.
*/
public Collection<Group> search(String query) {
Collection<String> groupNames = provider.search(query);
return new GroupCollection(groupNames);
}
/**
* Returns true if searching for groups is supported.
*
* @return true if searching for groups are supported.
*/
public boolean isSearchSupported() {
return provider.isSearchSupported();
}
/**
* Returns true if groups are read-only.
*
* @return true if groups are read-only.
*/
public boolean isReadOnly() {
return provider.isReadOnly();
}