org.eclipse.tracecompass.tmf.ui/src/org/eclipse/linuxtools/tmf/ui/views/uml2sd/dialogs/FilterCriteria.java

   1 /**********************************************************************
   2  * Copyright (c) 2005, 2013 IBM Corporation, Ericsson
   3  * All rights reserved.   This program and the accompanying materials
   4  * are made available under the terms of the Eclipse Public License v1.0
   5  * which accompanies this distribution, and is available at
   6  * http://www.eclipse.org/legal/epl-v10.html
   7  *
   8  * Contributors:
   9  *     IBM - Initial API and implementation
  10  *     Bernd Hufmann - Updated for TMF
  11  **********************************************************************/
  12
  13 package org.eclipse.linuxtools.tmf.ui.views.uml2sd.dialogs;
  14
  15 import java.util.Iterator;
  16 import java.util.List;
  17
  18 import org.eclipse.jface.dialogs.DialogSettings;
  19
  20 /**
  21  * A filter criteria is a criteria that can be activated or not, positive or not.
  22  *
  23  * @version 1.0
  24  * @author sveyrier
  25  *
  26  */
  27 public class FilterCriteria {
  28
  29     // ------------------------------------------------------------------------
  30     // Constants
  31     // ------------------------------------------------------------------------
  32     /**
  33      * The filter state value for 'active'.
  34      */
  35     protected static final String ACTIVE = "active"; //$NON-NLS-1$
  36     /**
  37      * The property value for positive filter.
  38      */
  39     protected static final String POSITIVE = "positive"; //$NON-NLS-1$
  40     /**
  41      * The filter loader class name property.
  42      */
  43     protected static final String LOADERCLASSNAME = "loaderClassName"; //$NON-NLS-1$
  44
  45     // ------------------------------------------------------------------------
  46     // Attributes
  47     // ------------------------------------------------------------------------
  48     /**
  49      * The criteria reference.
  50      */
  51     private Criteria fCriteria;
  52     /**
  53      * Flag whether this criteria is active or not
  54      */
  55     private boolean fIsActive;
  56     /**
  57      * Flag whether this criteria is for positive filter or not
  58      */
  59     private boolean fIsPositive;
  60     /**
  61      * The loader class name.
  62      */
  63     private String fLoaderClassName;
  64
  65     // ------------------------------------------------------------------------
  66     // Constructor
  67     // ------------------------------------------------------------------------
  68     /**
  69      * Standard constructor
  70      *
  71      * @param criteria A criteria reference
  72      * @param isActive <code>true</code> if filter criteria is active else <code>false</code>
  73      * @param isPositive  <code>true</code> for positive filter else <code>false</code>
  74      */
  75     public FilterCriteria(Criteria criteria, boolean isActive, boolean isPositive) {
  76         this(criteria, isActive, isPositive, null);
  77     }
  78
  79     /**
  80      * Constructor
  81      *
  82      * @param criteria A criteria reference
  83      * @param isActive <code>true</code> if filter criteria is active else <code>false</code>
  84      * @param isPositive  <code>true</code> for positive filter else <code>false</code>
  85      * @param loaderClassName A loader class name
  86      */
  87     public FilterCriteria(Criteria criteria, boolean isActive, boolean isPositive, String loaderClassName) {
  88         fCriteria = criteria;
  89         fIsActive = isActive;
  90         fIsPositive = isPositive;
  91         fLoaderClassName = loaderClassName;
  92     }
  93
  94     /**
  95      * Copy Constructor
  96      * @param other FilterCriteria
  97      */
  98     public FilterCriteria (FilterCriteria other) {
  99         fCriteria = new Criteria(other.fCriteria);
 100         fIsActive = other.fIsActive;
 101         fIsPositive = other.fIsPositive;
 102         fLoaderClassName = other.fLoaderClassName;
 103     }
 104
 105     /**
 106      * Default constructor
 107      */
 108     protected FilterCriteria() {
 109     }
 110
 111     // ------------------------------------------------------------------------
 112     // Methods
 113     // ------------------------------------------------------------------------
 114
 115     @Override
 116     public String toString() {
 117         StringBuffer sb = new StringBuffer(super.toString());
 118         sb.append(':');
 119         if (fCriteria != null) {
 120             sb.append(" expression=");sb.append(fCriteria.getExpression()); //$NON-NLS-1$
 121             sb.append(" active=");sb.append(fIsActive); //$NON-NLS-1$
 122             sb.append(" positive=");sb.append(fIsPositive); //$NON-NLS-1$
 123         } else {
 124             sb.append("empty criteria"); //$NON-NLS-1$
 125         }
 126         return sb.toString();
 127     }
 128
 129     /**
 130      * Sets a criteria reference.
 131      * @param criteria A criteria reference
 132      */
 133     public void setCriteria(Criteria criteria) {
 134         fCriteria = criteria;
 135     }
 136
 137     /**
 138      * Returns the criteria reference.
 139      *
 140      * @return the criteria reference
 141      */
 142     public Criteria getCriteria() {
 143         return fCriteria;
 144     }
 145
 146     /**
 147      * Sets the active flag.
 148      *
 149      * @param isActive A active value.
 150      */
 151     public void setActive(boolean isActive) {
 152         fIsActive = isActive;
 153     }
 154
 155     /**
 156      * Returns whether filter criteria is active or not.
 157      *
 158      * @return whether filter criteria is active or not.
 159      */
 160     public boolean isActive() {
 161         return fIsActive;
 162     }
 163
 164     /**
 165      * Sets filter is for positive filtering or not.
 166      *
 167      * @param isPositive The value to set.
 168      */
 169     public void setPositive(boolean isPositive) {
 170         fIsPositive = isPositive;
 171     }
 172
 173     /**
 174      * Returns whether the filter si for positive filtering or not.
 175      *
 176      * @return Returns the positive.
 177      */
 178     public boolean isPositive() {
 179         return fIsPositive;
 180     }
 181
 182     /**
 183      * Sets the loader class name for this filter.
 184      *
 185      * @param loaderClassName The loader class name to set
 186      */
 187     public void setLoaderClassName(String loaderClassName) {
 188         fLoaderClassName = loaderClassName;
 189     }
 190
 191     /**
 192      * Returns the class loader name.
 193      *
 194      * @return the class loader name.
 195      */
 196     public String getLoaderClassName() {
 197         return fLoaderClassName;
 198     }
 199
 200     /**
 201      * Finds a filter criteria within a  list of criteria.
 202      *
 203      * @param what The filter to find
 204      * @param list A list of filter criteria
 205      * @return The found filter criteria or null
 206      */
 207     public static FilterCriteria find(FilterCriteria what, List<FilterCriteria> list) {
 208         if (what != null && list != null) {
 209             try {
 210                 for (Iterator<FilterCriteria> i = list.iterator(); i.hasNext();) {
 211                     FilterCriteria fc = i.next();
 212                     if (what.compareTo(fc)) {
 213                         return fc;
 214                     }
 215                 }
 216             } catch (Exception e) {
 217                 // Silence
 218             }
 219         }
 220         return null;
 221     }
 222
 223     /**
 224      * Compares this filter criteria with a given criteria.
 225      *
 226      * @param to The filter criteria to compare.
 227      * @return usual comparison result (< 0, 0, > 0)
 228      */
 229     public boolean compareTo(FilterCriteria to) {
 230         if (isPositive() == to.isPositive() && getCriteria().compareTo(to.getCriteria())) {
 231             if (getLoaderClassName() == null && to.getLoaderClassName() == null) {
 232                 return true;
 233             }
 234             if ((getLoaderClassName() != null && to.getLoaderClassName() != null) && getLoaderClassName().equals(to.getLoaderClassName())) {
 235                 return true;
 236             }
 237         }
 238         return false;
 239     }
 240
 241     /**
 242      * Saves current criteria attributes in the dialog settings.
 243      *
 244      * @param settings The dialog settings
 245      */
 246     public void save(DialogSettings settings) {
 247         settings.put(ACTIVE, isActive());
 248         settings.put(POSITIVE, isPositive());
 249         if (getLoaderClassName() != null) {
 250             settings.put(LOADERCLASSNAME, getLoaderClassName());
 251         } else {
 252             settings.put(LOADERCLASSNAME, ""); //$NON-NLS-1$
 253         }
 254         if (fCriteria != null) {
 255             fCriteria.save(settings);
 256         }
 257     }
 258
 259     /**
 260      * Loads the criteria with values of the dialog settings.
 261      *
 262      * @param settings The dialog settings
 263      */
 264     public void load(DialogSettings settings) {
 265         setActive(settings.getBoolean(ACTIVE));
 266         setPositive(settings.getBoolean(POSITIVE));
 267         String loaderClassName = settings.get(LOADERCLASSNAME);
 268         setLoaderClassName(loaderClassName != null && loaderClassName.length() > 0 ? loaderClassName : null);
 269         if (fCriteria != null) {
 270             fCriteria.load(settings);
 271         }
 272     }
 273 }