mirrors/cdt
1
0
Fork 0
mirror of https://github.com/eclipse-cdt/cdt synced 2025-07-15 13:05: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

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