mirrors/cdt
1
0
Fork 0
mirror of https://github.com/eclipse-cdt/cdt synced 2025-07-15 04:55:22 +02:00
Code Issues Wiki Activity

[189274] formatting prior to adding new operations for adding filters

Browse source 
https://bugs.eclipse.org/bugs/show_bug.cgi?id=189274
This commit is contained in:
David Dykstal 2008-03-11 00:19:46 +00:00
parent 894fbb040a
commit a6e7bc0b7f
1 changed files with 444 additions and 512 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

956
rse/plugins/org.eclipse.rse.core/src/org/eclipse/rse/internal/core/filters/SystemFilterContainerCommonMethods.java
View file

@ -15,6 +15,7 @@
********************************************************************************/ ********************************************************************************/
package org.eclipse.rse.internal.core.filters; package org.eclipse.rse.internal.core.filters;
import java.util.Iterator; import java.util.Iterator;
import java.util.Vector; import java.util.Vector;
@ -23,7 +24,6 @@ import org.eclipse.rse.core.filters.ISystemFilter;
import org.eclipse.rse.core.filters.ISystemFilterPool; import org.eclipse.rse.core.filters.ISystemFilterPool;
import org.eclipse.rse.logging.Logger; import org.eclipse.rse.logging.Logger;
/** /**
* This class abstracts out some common code needed by any class that * This class abstracts out some common code needed by any class that
* implements ISystemFilterContainer. * implements ISystemFilterContainer.
@ -34,537 +34,469 @@ import org.eclipse.rse.logging.Logger;
* are stored internally. * are stored internally.
*/ */
public class SystemFilterContainerCommonMethods public class SystemFilterContainerCommonMethods
//implements ISystemFilterContainer //implements ISystemFilterContainer
{ {
private Vector filterNameVector, filterVector; private Vector filterNameVector, filterVector;
private ISystemFilter[] filterArray; private ISystemFilter[] filterArray;
/** /**
* Constructor * Constructor
*/ */
public SystemFilterContainerCommonMethods() public SystemFilterContainerCommonMethods() {
{
super(); super();
} }
/**
/** * For performance reasons we have decided to store a cache of the
* For performance reasons we have decided to store a cache of the * filters in vector and array form, so each request will not result
* filters in vector and array form, so each request will not result * in a new temporary vector or array. However, this cache can get out
* in a new temporary vector or array. However, this cache can get out * of date, so this method must be called religiously to invalidate it
* of date, so this method must be called religiously to invalidate it * after any change in the filters.
* after any change in the filters. */
*/ public void invalidateCache() {
public void invalidateCache() filterNameVector = filterVector = null;
{ filterArray = null;
filterNameVector = filterVector = null; }
filterArray = null;
} /**
* Creates a new system filter within this pool or filter.
/** * @param filters MOF list of filters the new filter is to be added to.
* Creates a new system filter within this pool or filter. * @param parentPool pool that contains this filter (directly or indirectly).
* @param filters MOF list of filters the new filter is to be added to. * @param aliasName The name to give the new filter. Must be unique for this pool.
* @param parentPool pool that contains this filter (directly or indirectly). * @param filterStrings The list of String objects that represent the filter strings.
* @param aliasName The name to give the new filter. Must be unique for this pool. */
* @param filterStrings The list of String objects that represent the filter strings. public ISystemFilter createSystemFilter(java.util.List filters, ISystemFilterPool parentPool, String aliasName, Vector filterStrings) {
*/ ISystemFilter newFilter = null;
public ISystemFilter createSystemFilter(java.util.List filters,
ISystemFilterPool parentPool, // FIXME - not using error message and null return
String aliasName, Vector filterStrings) // because I want to restore filters while not being hit with conflicts
{ newFilter = getSystemFilter(filters, aliasName);
ISystemFilter newFilter = null; if (newFilter != null) {
return newFilter;
// FIXME - not using error message and null return }
// because I want to restore filters while not being hit with conflicts /* DKM
newFilter = getSystemFilter(filters, aliasName); boolean exists = getSystemFilter(filters, aliasName) != null;
if (newFilter != null) if (exists)
{ {
return newFilter; String msg = "Error creating filter: aliasName " + aliasName + " is not unique"; // no need to xlate, internal only
}
/* DKM
boolean exists = getSystemFilter(filters, aliasName) != null;
if (exists)
{
String msg = "Error creating filter: aliasName " + aliasName + " is not unique"; // no need to xlate, internal only
RSEUIPlugin.logError(msg); RSEUIPlugin.logError(msg);
return null; return null;
} }
*/ */
newFilter = internalCreateSystemFilter(parentPool, aliasName, filterStrings); newFilter = internalCreateSystemFilter(parentPool, aliasName, filterStrings);
if (newFilter != null) if (newFilter != null) internalAddSystemFilter(filters, newFilter);
internalAddSystemFilter(filters, newFilter); return newFilter;
return newFilter; }
}
/**
* Creates a new system filter within this pool or filter.
* @param filters Vector of filters the new filter is to be added to.
* @param parentPool pool that contains this filter (directly or indirectly)
* @param aliasName The name to give the new filter. Must be unique for this pool.
* @param filterStrings The list of String objects that represent the filter strings.
*/
public ISystemFilter createSystemFilter(Vector filters,
ISystemFilterPool parentPool,
String aliasName, Vector filterStrings)
{
ISystemFilter newFilter = null;
boolean exists = getSystemFilter(filters, aliasName) != null;
if (exists)
{
String msg = "Error creating filter: aliasName " + aliasName + " is not unique"; // no need to xlate, internal only //$NON-NLS-1$ //$NON-NLS-2$
RSECorePlugin.getDefault().getLogger().logError(msg, null);
return null;
}
newFilter = internalCreateSystemFilter(parentPool, aliasName, filterStrings);
if (newFilter != null)
internalAddSystemFilter(filters, newFilter);
return newFilter;
}
/** /**
* Internal encapsulation of mof effort to create new filter, and setting of * Creates a new system filter within this pool or filter.
* the core attributes. * @param filters Vector of filters the new filter is to be added to.
*/ * @param parentPool pool that contains this filter (directly or indirectly)
private ISystemFilter internalCreateSystemFilter( * @param aliasName The name to give the new filter. Must be unique for this pool.
ISystemFilterPool parentPool, * @param filterStrings The list of String objects that represent the filter strings.
String aliasName, Vector filterStrings) */
{ public ISystemFilter createSystemFilter(Vector filters, ISystemFilterPool parentPool, String aliasName, Vector filterStrings) {
ISystemFilter newFilter = null; ISystemFilter newFilter = null;
try boolean exists = getSystemFilter(filters, aliasName) != null;
{ if (exists) {
newFilter = new SystemFilter(); String msg = "Error creating filter: aliasName " + aliasName + " is not unique"; // no need to xlate, internal only //$NON-NLS-1$ //$NON-NLS-2$
// FIXME getMOFfactory().createSystemFilter(); RSECorePlugin.getDefault().getLogger().logError(msg, null);
newFilter.setRelease(RSECorePlugin.CURRENT_RELEASE); return null;
newFilter.setName(aliasName); }
newFilter.setParentFilterPool(parentPool); newFilter = internalCreateSystemFilter(parentPool, aliasName, filterStrings);
if (filterStrings != null) if (newFilter != null) internalAddSystemFilter(filters, newFilter);
newFilter.setFilterStrings(filterStrings); return newFilter;
//java.util.List filterStringList = newFilter.getFilterStrings(); }
//for (int idx=0; idx<filterStrings.size(); idx++)
//{
//SystemFilterString string = getMOFfactory().createSystemFilterString();
//string.setString((String)filterStrings.elementAt(idx));
//filterStringList.add(string);
//}
} catch (Exception e)
{
Logger logger = RSECorePlugin.getDefault().getLogger();
logger.logError("Error creating filter: " + e.getClass().getName() + ": " + e.getMessage(), null); //$NON-NLS-1$ //$NON-NLS-2$
logger.logError("...Alias name.: " + aliasName, null); //$NON-NLS-1$
}
return newFilter;
}
/**
* Internal encapsulation of mof effort to create new filter, and setting of
* the core attributes.
*/
private ISystemFilter internalCreateSystemFilter(ISystemFilterPool parentPool, String aliasName, Vector filterStrings) {
ISystemFilter newFilter = null;
try {
newFilter = new SystemFilter();
// FIXME getMOFfactory().createSystemFilter();
newFilter.setRelease(RSECorePlugin.CURRENT_RELEASE);
newFilter.setName(aliasName);
newFilter.setParentFilterPool(parentPool);
if (filterStrings != null) newFilter.setFilterStrings(filterStrings);
//java.util.List filterStringList = newFilter.getFilterStrings();
//for (int idx=0; idx<filterStrings.size(); idx++)
//{
//SystemFilterString string = getMOFfactory().createSystemFilterString();
//string.setString((String)filterStrings.elementAt(idx));
//filterStringList.add(string);
//}
} catch (Exception e) {
Logger logger = RSECorePlugin.getDefault().getLogger();
logger.logError("Error creating filter: " + e.getClass().getName() + ": " + e.getMessage(), null); //$NON-NLS-1$ //$NON-NLS-2$
logger.logError("...Alias name.: " + aliasName, null); //$NON-NLS-1$
}
return newFilter;
}
/** /**
* Return Vector of String objects: the names of existing filters in this container. * Return Vector of String objects: the names of existing filters in this container.
* Needed by name validators for New and Rename actions to verify new name is unique. * Needed by name validators for New and Rename actions to verify new name is unique.
*/ */
public Vector getSystemFilterNames(java.util.List filters) public Vector getSystemFilterNames(java.util.List filters) {
{ if ((filterNameVector == null) || (filterNameVector.size() != filters.size())) {
if ((filterNameVector == null) || (filterNameVector.size() != filters.size())) filterNameVector = new Vector();
{ if (filters == null) return filterNameVector;
filterNameVector = new Vector(); Iterator i = filters.iterator();
if (filters == null) while (i.hasNext()) {
return filterNameVector; ISystemFilter next = (ISystemFilter) i.next();
Iterator i = filters.iterator(); filterNameVector.addElement(next.getName());
while (i.hasNext()) }
{ }
ISystemFilter next = (ISystemFilter)i.next(); return filterNameVector;
filterNameVector.addElement(next.getName()); }
}
}
return filterNameVector;
}
/**
* Return Vector of String objects: the names of existing filters in this container.
* Needed by name validators for New and Rename actions to verify new name is unique.
*/
public Vector getSystemFilterNames(Vector filters)
{
if ((filterNameVector == null) || (filterNameVector.size() != filters.size()))
{
Vector filterNameVector = new Vector();
if ((filters == null) || (filters.size()==0))
return filterNameVector;
for (int idx=0; idx<filters.size(); idx++)
{
ISystemFilter next = (ISystemFilter)filters.elementAt(idx);
filterNameVector.addElement(next.getName());
}
}
return filterNameVector;
}
/**
* Return the nested filters as a Vector
*/
public Vector getSystemFiltersVector(java.util.List filters)
{
if ((filterVector == null) || (filterVector.size() != filters.size()))
{
filterVector = new Vector();
Iterator i = filters.iterator();
while (i.hasNext())
filterVector.addElement(i.next());
}
return filterVector;
}
/**
* Return the nested filters as a Vector
*/
public Vector getSystemFiltersVector(Vector filters)
{
return filters;
}
/** /**
* Return the nested filters as an array * Return Vector of String objects: the names of existing filters in this container.
*/ * Needed by name validators for New and Rename actions to verify new name is unique.
public ISystemFilter[] getSystemFilters(java.util.List filters) */
{ public Vector getSystemFilterNames(Vector filters) {
if ((filterArray == null) || (filterArray.length != filters.size())) if ((filterNameVector == null) || (filterNameVector.size() != filters.size())) {
{ Vector filterNameVector = new Vector();
filterArray = new ISystemFilter[filters.size()]; if ((filters == null) || (filters.size() == 0)) return filterNameVector;
Iterator i = filters.iterator(); for (int idx = 0; idx < filters.size(); idx++) {
int idx = 0; ISystemFilter next = (ISystemFilter) filters.elementAt(idx);
while (i.hasNext()) filterNameVector.addElement(next.getName());
filterArray[idx++]=(ISystemFilter)(i.next()); }
} }
return filterArray; return filterNameVector;
//return null; }
}
/**
* Return the filters as an array
*/
public ISystemFilter[] getSystemFilters(Vector filters)
{
if (filters == null)
return null;
if ((filterArray == null) || (filterArray.length != filters.size()))
{
filterArray = new ISystemFilter[filters.size()];
for (int idx=0; idx<filters.size(); idx++)
filterArray[idx]=(ISystemFilter)(filters.elementAt(idx));
}
return filterArray;
}
/** /**
* Return how many filters are defined in this filter container * Return the nested filters as a Vector
*/ */
public int getSystemFilterCount(java.util.List filters) public Vector getSystemFiltersVector(java.util.List filters) {
{ if ((filterVector == null) || (filterVector.size() != filters.size())) {
int nbrChildren = (filters == null) ? 0 : filters.size(); filterVector = new Vector();
return nbrChildren; Iterator i = filters.iterator();
} while (i.hasNext())
filterVector.addElement(i.next());
}
return filterVector;
}
/** /**
* Return how many filters are defined in this filter container * Return the nested filters as a Vector
*/ */
public int getSystemFilterCount(Vector filters) public Vector getSystemFiltersVector(Vector filters) {
{ return filters;
int nbrChildren = (filters == null) ? 0 : filters.size(); }
return nbrChildren;
}
/**
* Return true if there are system filters
*/
public boolean hasSystemFilters(java.util.List filters)
{
return (filters!=null) && (filters.size()>0);
}
/**
* Return true if there are system filters
*/
public boolean hasSystemFilters(Vector filters)
{
return (filters!=null) && (filters.size()>0);
}
/**
/** * Return the nested filters as an array
* Return a filter object, given its aliasname. */
* Can be used to test if an aliasname is already used (non-null return). public ISystemFilter[] getSystemFilters(java.util.List filters) {
* @param aliasName unique aliasName (case insensitive) to search on. if ((filterArray == null) || (filterArray.length != filters.size())) {
* @return SystemFilter object with unique aliasName, or null if filterArray = new ISystemFilter[filters.size()];
* no filter object with this name exists. Iterator i = filters.iterator();
*/ int idx = 0;
public ISystemFilter getSystemFilter(java.util.List filters, String aliasName) while (i.hasNext())
{ filterArray[idx++] = (ISystemFilter) (i.next());
ISystemFilter filter = null; }
ISystemFilter currFilter = null; return filterArray;
Iterator i = filters.iterator(); //return null;
while (i.hasNext() && (filter==null)) }
{
currFilter = (ISystemFilter)i.next();
if (currFilter.getName().equalsIgnoreCase(aliasName))
filter = currFilter;
}
return filter;
}
/**
* Return a filter object, given its aliasname.
* Can be used to test if an aliasname is already used (non-null return).
* @param aliasName unique aliasName (case insensitive) to search on.
* @return SystemFilter object with unique aliasName, or null if
* no filter object with this name exists.
*/
public ISystemFilter getSystemFilter(Vector filters, String aliasName)
{
if ((filters == null) || (filters.size()==0))
return null;
ISystemFilter filter = null;
ISystemFilter currFilter = null;
for (int idx=0; (idx<filters.size()) && (filter==null); idx++)
{
currFilter = (ISystemFilter)filters.elementAt(idx);
if (currFilter.getName().equalsIgnoreCase(aliasName))
filter = currFilter;
}
return filter;
}
/**
* Adds given filter to the list.
* <p>PLEASE NOTE:
* <ul>
* <li> createSystemFilter calls this method for you!
* <li> this is a no-op if a filter with the same aliasname already exists
* </ul>
* @param filter SystemFilter object to add
* @return true if added, false if filter with this aliasname already existed.
*/
public boolean addSystemFilter(java.util.List filters, ISystemFilter filter)
{
boolean exists = getSystemFilter(filters, filter.getName()) != null;
if (!exists)
return internalAddSystemFilter(filters, filter);
else
return false;
}
/**
* Internally, we can skip the uniqueness checking.
*/
protected boolean internalAddSystemFilter(java.util.List filters, ISystemFilter filter)
{
filters.add(filter);
invalidateCache();
return true;
}
/**
* Adds given filter to the list.
* <p>PLEASE NOTE:
* <ul>
* <li> createSystemFilter calls this method for you!
* <li> this is a no-op if a filter with the same aliasname already exists
* </ul>
* @param filter SystemFilter object to add
* @return true if added, false if filter with this aliasname already existed.
*/
public boolean addSystemFilter(Vector filters, ISystemFilter filter)
{
boolean exists = getSystemFilter(filters, filter.getName()) != null;
if (!exists)
return internalAddSystemFilter(filters, filter);
else
return false;
}
/**
* Internally, we can skip the uniqueness checking.
*/
private boolean internalAddSystemFilter(Vector filters, ISystemFilter filter)
{
filters.add(filter);
invalidateCache();
return true;
}
/** /**
* Removes a given filter from the list. * Return the filters as an array
* Does NOT follow references to remove them. */
* @param filters MOF list to remove from public ISystemFilter[] getSystemFilters(Vector filters) {
* @param filter SystemFilter object to remove if (filters == null) return null;
*/ if ((filterArray == null) || (filterArray.length != filters.size())) {
public void deleteSystemFilter(java.util.List filters, ISystemFilter filter) filterArray = new ISystemFilter[filters.size()];
{ for (int idx = 0; idx < filters.size(); idx++)
filters.remove(filter); filterArray[idx] = (ISystemFilter) (filters.elementAt(idx));
invalidateCache(); }
} return filterArray;
/** }
* Renames a given filter from the list.
* @param filters java.util.List list
* @param filter SystemFilter object to rename
* @param newName new name to give filter
*/
public void renameSystemFilter(java.util.List filters, ISystemFilter filter, String newName)
{
filter.setName(newName);
invalidateCache();
}
/** /**
* Removes a given filter from the list. * Return how many filters are defined in this filter container
* Does NOT follow references to remove them. */
* @param filters Vector list to remove from public int getSystemFilterCount(java.util.List filters) {
* @param filter SystemFilter object to remove int nbrChildren = (filters == null) ? 0 : filters.size();
*/ return nbrChildren;
public void deleteSystemFilter(Vector filters, ISystemFilter filter) }
{
filters.remove(filter);
invalidateCache();
}
/**
* Renames a given filter from the list.
* @param filters Vector list
* @param filter SystemFilter object to rename
* @param newName new name to give filter
*/
public void renameSystemFilter(Vector filters, ISystemFilter filter, String newName)
{
filter.setName(newName);
invalidateCache();
}
/**
* Updates a given filter in the list.
* @param filters Vector list
* @param filter SystemFilter object to update
* @param newName new name to give filter
* @param newStrings new strings to give filter
*/
public void updateSystemFilter(Vector filters, ISystemFilter filter, String newName, String[] newStrings)
{
filter.setName(newName);
filter.setFilterStrings(newStrings);
invalidateCache();
}
/**
* Updates a given filter in the list.
* @param filters java.util.List list
* @param filter SystemFilter object to update
* @param newName new name to give filter
* @param newStrings new strings to give filter
*/
public void updateSystemFilter(java.util.List filters, ISystemFilter filter, String newName, String[] newStrings)
{
filter.setName(newName);
filter.setFilterStrings(newStrings);
invalidateCache();
}
/**
* Duplicates a given filter in the list.
* @param filters MOF list of filters into which to place the clone
* @param filter SystemFilter object to clone
* @param aliasName New, unique, alias name to give this filter. Clone will fail if this is not unique.
*/
public ISystemFilter cloneSystemFilter(java.util.List filters, ISystemFilter filter, String aliasName)
{
ISystemFilter copy = /**
createSystemFilter(filters, filter.getParentFilterPool(), * Return how many filters are defined in this filter container
aliasName, filter.getFilterStringsVector()); */
internalAfterCloneSystemFilter(filter, copy); public int getSystemFilterCount(Vector filters) {
// now clone nested filters... int nbrChildren = (filters == null) ? 0 : filters.size();
ISystemFilter[] nested = filter.getSystemFilters(); return nbrChildren;
if ((nested!=null) && (nested.length>0)) }
for (int idx=0; idx<nested.length; idx++)
{
}
return copy;
}
/**
* Duplicates a given filter in the list.
* @param filters Vector of filters into which to place the clone
* @param filter SystemFilter object to clone
* @param aliasName New, unique, alias name to give this filter. Clone will fail if this is not unique.
*/
public ISystemFilter cloneSystemFilter(Vector filters, ISystemFilter filter, String aliasName)
{
ISystemFilter copy = /**
createSystemFilter(filters, filter.getParentFilterPool(), * Return true if there are system filters
aliasName, filter.getFilterStringsVector()); */
internalAfterCloneSystemFilter(filter, copy); public boolean hasSystemFilters(java.util.List filters) {
// now clone nested filters... return (filters != null) && (filters.size() > 0);
ISystemFilter[] nested = filter.getSystemFilters(); }
if ((nested!=null) && (nested.length>0))
for (int idx=0; idx<nested.length; idx++)
{
}
return copy;
}
/** /**
* Does core effort to populate a filter clone with non-core attributes * Return true if there are system filters
* @param oldFilter SystemFilter original filter */
* @param newFilter SystemFilter that is new public boolean hasSystemFilters(Vector filters) {
*/ return (filters != null) && (filters.size() > 0);
public void internalAfterCloneSystemFilter(ISystemFilter oldFilter, ISystemFilter newFilter) }
{
newFilter.setParentFilterPool(oldFilter.getParentFilterPool());
newFilter.setSupportsNestedFilters(oldFilter.isSupportsNestedFilters());
newFilter.setType(oldFilter.getType());
newFilter.setDefault(oldFilter.isDefault());
newFilter.setRelativeOrder(oldFilter.getRelativeOrder());
}
/** /**
* Return a given filter's zero-based location * Return a filter object, given its aliasname.
*/ * Can be used to test if an aliasname is already used (non-null return).
public int getSystemFilterPosition(java.util.List filters, ISystemFilter filter) * @param aliasName unique aliasName (case insensitive) to search on.
{ * @return SystemFilter object with unique aliasName, or null if
int position = -1; * no filter object with this name exists.
Iterator i = filters.iterator(); */
for (int idx=0; (position<0) && (idx < filters.size()); idx++) public ISystemFilter getSystemFilter(java.util.List filters, String aliasName) {
{ ISystemFilter filter = null;
ISystemFilter currFilter = (ISystemFilter)i.next(); ISystemFilter currFilter = null;
if (currFilter.getName().equals(filter.getName())) Iterator i = filters.iterator();
position = idx; while (i.hasNext() && (filter == null)) {
} currFilter = (ISystemFilter) i.next();
return position; if (currFilter.getName().equalsIgnoreCase(aliasName)) filter = currFilter;
} }
/** return filter;
* Return a given filter's zero-based location }
*/
public int getSystemFilterPosition(Vector filters, ISystemFilter filter)
{
int position = -1;
for (int idx=0; (position<0) && (idx < filters.size()); idx++)
{
ISystemFilter currFilter = (ISystemFilter)filters.elementAt(idx);
if (currFilter.getName().equals(filter.getName()))
position = idx;
}
return position;
}
/**
/** * Return a filter object, given its aliasname.
* Move a given filter to a given zero-based location * Can be used to test if an aliasname is already used (non-null return).
*/ * @param aliasName unique aliasName (case insensitive) to search on.
public void moveSystemFilter(java.util.List filters, int pos, ISystemFilter filter) * @return SystemFilter object with unique aliasName, or null if
{ * no filter object with this name exists.
filters.remove(filter); */
filters.add(pos, filter); public ISystemFilter getSystemFilter(Vector filters, String aliasName) {
invalidateCache(); if ((filters == null) || (filters.size() == 0)) return null;
} ISystemFilter filter = null;
/** ISystemFilter currFilter = null;
* Move a given filter to a given zero-based location for (int idx = 0; (idx < filters.size()) && (filter == null); idx++) {
*/ currFilter = (ISystemFilter) filters.elementAt(idx);
public void moveSystemFilter(Vector filters, int pos, ISystemFilter filter) if (currFilter.getName().equalsIgnoreCase(aliasName)) filter = currFilter;
{ }
filters.remove(filter); return filter;
filters.insertElementAt(filter, pos); }
invalidateCache();
}
} /**
* Adds given filter to the list.
* <p>PLEASE NOTE:
* <ul>
* <li> createSystemFilter calls this method for you!
* <li> this is a no-op if a filter with the same aliasname already exists
* </ul>
* @param filter SystemFilter object to add
* @return true if added, false if filter with this aliasname already existed.
*/
public boolean addSystemFilter(java.util.List filters, ISystemFilter filter) {
boolean exists = getSystemFilter(filters, filter.getName()) != null;
if (!exists)
return internalAddSystemFilter(filters, filter);
else
return false;
}
/**
* Internally, we can skip the uniqueness checking.
*/
protected boolean internalAddSystemFilter(java.util.List filters, ISystemFilter filter) {
filters.add(filter);
invalidateCache();
return true;
}
/**
* Adds given filter to the list.
* <p>PLEASE NOTE:
* <ul>
* <li> createSystemFilter calls this method for you!
* <li> this is a no-op if a filter with the same aliasname already exists
* </ul>
* @param filter SystemFilter object to add
* @return true if added, false if filter with this aliasname already existed.
*/
public boolean addSystemFilter(Vector filters, ISystemFilter filter) {
boolean exists = getSystemFilter(filters, filter.getName()) != null;
if (!exists)
return internalAddSystemFilter(filters, filter);
else
return false;
}
/**
* Internally, we can skip the uniqueness checking.
*/
private boolean internalAddSystemFilter(Vector filters, ISystemFilter filter) {
filters.add(filter);
invalidateCache();
return true;
}
/**
* Removes a given filter from the list.
* Does NOT follow references to remove them.
* @param filters MOF list to remove from
* @param filter SystemFilter object to remove
*/
public void deleteSystemFilter(java.util.List filters, ISystemFilter filter) {
filters.remove(filter);
invalidateCache();
}
/**
* Renames a given filter from the list.
* @param filters java.util.List list
* @param filter SystemFilter object to rename
* @param newName new name to give filter
*/
public void renameSystemFilter(java.util.List filters, ISystemFilter filter, String newName) {
filter.setName(newName);
invalidateCache();
}
/**
* Removes a given filter from the list.
* Does NOT follow references to remove them.
* @param filters Vector list to remove from
* @param filter SystemFilter object to remove
*/
public void deleteSystemFilter(Vector filters, ISystemFilter filter) {
filters.remove(filter);
invalidateCache();
}
/**
* Renames a given filter from the list.
* @param filters Vector list
* @param filter SystemFilter object to rename
* @param newName new name to give filter
*/
public void renameSystemFilter(Vector filters, ISystemFilter filter, String newName) {
filter.setName(newName);
invalidateCache();
}
/**
* Updates a given filter in the list.
* @param filters Vector list
* @param filter SystemFilter object to update
* @param newName new name to give filter
* @param newStrings new strings to give filter
*/
public void updateSystemFilter(Vector filters, ISystemFilter filter, String newName, String[] newStrings) {
filter.setName(newName);
filter.setFilterStrings(newStrings);
invalidateCache();
}
/**
* Updates a given filter in the list.
* @param filters java.util.List list
* @param filter SystemFilter object to update
* @param newName new name to give filter
* @param newStrings new strings to give filter
*/
public void updateSystemFilter(java.util.List filters, ISystemFilter filter, String newName, String[] newStrings) {
filter.setName(newName);
filter.setFilterStrings(newStrings);
invalidateCache();
}
/**
* Duplicates a given filter in the list.
* @param filters MOF list of filters into which to place the clone
* @param filter SystemFilter object to clone
* @param aliasName New, unique, alias name to give this filter. Clone will fail if this is not unique.
*/
public ISystemFilter cloneSystemFilter(java.util.List filters, ISystemFilter filter, String aliasName) {
ISystemFilter copy = createSystemFilter(filters, filter.getParentFilterPool(), aliasName, filter.getFilterStringsVector());
internalAfterCloneSystemFilter(filter, copy);
// now clone nested filters...
ISystemFilter[] nested = filter.getSystemFilters();
if ((nested != null) && (nested.length > 0)) for (int idx = 0; idx < nested.length; idx++) {
}
return copy;
}
/**
* Duplicates a given filter in the list.
* @param filters Vector of filters into which to place the clone
* @param filter SystemFilter object to clone
* @param aliasName New, unique, alias name to give this filter. Clone will fail if this is not unique.
*/
public ISystemFilter cloneSystemFilter(Vector filters, ISystemFilter filter, String aliasName) {
ISystemFilter copy = createSystemFilter(filters, filter.getParentFilterPool(), aliasName, filter.getFilterStringsVector());
internalAfterCloneSystemFilter(filter, copy);
// now clone nested filters...
ISystemFilter[] nested = filter.getSystemFilters();
if ((nested != null) && (nested.length > 0)) for (int idx = 0; idx < nested.length; idx++) {
}
return copy;
}
/**
* Does core effort to populate a filter clone with non-core attributes
* @param oldFilter SystemFilter original filter
* @param newFilter SystemFilter that is new
*/
public void internalAfterCloneSystemFilter(ISystemFilter oldFilter, ISystemFilter newFilter) {
newFilter.setParentFilterPool(oldFilter.getParentFilterPool());
newFilter.setSupportsNestedFilters(oldFilter.isSupportsNestedFilters());
newFilter.setType(oldFilter.getType());
newFilter.setDefault(oldFilter.isDefault());
newFilter.setRelativeOrder(oldFilter.getRelativeOrder());
}
/**
* Return a given filter's zero-based location
*/
public int getSystemFilterPosition(java.util.List filters, ISystemFilter filter) {
int position = -1;
Iterator i = filters.iterator();
for (int idx = 0; (position < 0) && (idx < filters.size()); idx++) {
ISystemFilter currFilter = (ISystemFilter) i.next();
if (currFilter.getName().equals(filter.getName())) position = idx;
}
return position;
}
/**
* Return a given filter's zero-based location
*/
public int getSystemFilterPosition(Vector filters, ISystemFilter filter) {
int position = -1;
for (int idx = 0; (position < 0) && (idx < filters.size()); idx++) {
ISystemFilter currFilter = (ISystemFilter) filters.elementAt(idx);
if (currFilter.getName().equals(filter.getName())) position = idx;
}
return position;
}
/**
* Move a given filter to a given zero-based location
*/
public void moveSystemFilter(java.util.List filters, int pos, ISystemFilter filter) {
filters.remove(filter);
filters.add(pos, filter);
invalidateCache();
}
/**
* Move a given filter to a given zero-based location
*/
public void moveSystemFilter(Vector filters, int pos, ISystemFilter filter) {
filters.remove(filter);
filters.insertElementAt(filter, pos);
invalidateCache();
}
}