platform/structuralsearch/source/com/intellij/structuralsearch/MatchVariableConstraint.java

package com.intellij.structuralsearch;

import org.jdom.Element;
import org.jdom.Attribute;
import org.jdom.DataConversionException;
import org.jetbrains.annotations.NonNls;

/**
 * @author Maxim.Mossienko
 * Date: Mar 19, 2004
 * Time: 5:36:32 PM
 */
public class MatchVariableConstraint extends NamedScriptableDefinition {
  private String regExp = "";
  private boolean invertRegExp;
  private boolean withinHierarchy;
  private boolean strictlyWithinHierarchy;
  private boolean wholeWordsOnly;
  private int minCount = 1;
  private int maxCount = 1;
  private boolean readAccess;
  private boolean invertReadAccess;
  private boolean writeAccess;
  private boolean invertWriteAccess;
  private boolean greedy = true;
  private boolean reference;
  private boolean invertReference;
  private String nameOfReferenceVar = "";
  private boolean partOfSearchResults;
  private String nameOfExprType = "";
  private boolean invertExprType;
  private boolean exprTypeWithinHierarchy;

  private String nameOfFormalArgType = "";
  private boolean invertFormalType;
  private boolean formalArgTypeWithinHierarchy;

  private String withinConstraint = "";
  private String containsConstraint = "";
  private boolean invertContainsConstraint;
  private boolean invertWithinConstraint;
  private final boolean artificial;

  @NonNls private static final String NAME_OF_REFEENCE_VAR = "nameOfReferenceVar";
  @NonNls private static final String NAME_OF_EXPRTYPE = "nameOfExprType";
  @NonNls private static final String NAME_OF_FORMALTYPE = "nameOfFormalType";
  @NonNls private static final String REGEXP = "regexp";
  @NonNls private static final String EXPRTYPE_WITHIN_HIERARCHY = "exprTypeWithinHierarchy";
  @NonNls private static final String FORMALTYPE_WITHIN_HIERARCHY = "formalTypeWithinHierarchy";

  @NonNls private static final String WITHIN_HIERARCHY = "withinHierarchy";
  @NonNls private static final String MAX_OCCURS = "maxCount";
  @NonNls private static final String MIN_OCCURS = "minCount";

  @NonNls private static final String NEGATE_NAME_CONDITION = "negateName";
  @NonNls private static final String NEGATE_EXPRTYPE_CONDITION = "negateExprType";
  @NonNls private static final String NEGATE_FORMALTYPE_CONDITION = "negateFormalType";
  @NonNls private static final String NEGATE_READ_CONDITION = "negateRead";
  @NonNls private static final String NEGATE_WRITE_CONDITION = "negateWrite";
  @NonNls private static final String NEGATE_CONTAINS_CONDITION = "negateContains";
  @NonNls private static final String NEGATE_WITHIN_CONDITION = "negateWithin";
  @NonNls private static final String WITHIN_CONDITION = "within";
  @NonNls private static final String CONTAINS_CONDITION = "contains";
  @NonNls private static final String READ = "readAccess";
  @NonNls private static final String WRITE = "writeAccess";
  @NonNls private static final String TARGET = "target";

  @NonNls private static final String WHOLE_WORDS_ONLY = "wholeWordsOnly";
  @NonNls private static final String TRUE = Boolean.TRUE.toString();

  public MatchVariableConstraint() { this(false); }
  public MatchVariableConstraint(boolean _artificial) { artificial = _artificial; }

  public boolean isGreedy() {
    return greedy;
  }

  public void setGreedy(boolean greedy) {
    this.greedy = greedy;
  }

  public String getRegExp() {
    return regExp;
  }

  public void setRegExp(String regExp) {
    this.regExp = regExp;
  }

  public boolean isInvertRegExp() {
    return invertRegExp;
  }

  public void setInvertRegExp(boolean invertRegExp) {
    this.invertRegExp = invertRegExp;
  }

  public boolean isWithinHierarchy() {
    return withinHierarchy;
  }

  public void setWithinHierarchy(boolean withinHierarchy) {
    this.withinHierarchy = withinHierarchy;
  }

  public int getMinCount() {
    return minCount;
  }

  public void setMinCount(int minCount) {
    this.minCount = minCount;
  }

  public int getMaxCount() {
    return maxCount;
  }

  public void setMaxCount(int maxCount) {
    this.maxCount = maxCount;
  }

  public boolean isReadAccess() {
    return readAccess;
  }

  public void setReadAccess(boolean readAccess) {
    this.readAccess = readAccess;
  }

  public boolean isInvertReadAccess() {
    return invertReadAccess;
  }

  public void setInvertReadAccess(boolean invertReadAccess) {
    this.invertReadAccess = invertReadAccess;
  }

  public boolean isWriteAccess() {
    return writeAccess;
  }

  public void setWriteAccess(boolean writeAccess) {
    this.writeAccess = writeAccess;
  }

  public boolean isInvertWriteAccess() {
    return invertWriteAccess;
  }

  public void setInvertWriteAccess(boolean invertWriteAccess) {
    this.invertWriteAccess = invertWriteAccess;
  }

  public boolean isPartOfSearchResults() {
    return partOfSearchResults;
  }

  public void setPartOfSearchResults(boolean partOfSearchResults) {
    this.partOfSearchResults = partOfSearchResults;
  }

  public boolean isReference() {
    return reference;
  }

  public void setReference(boolean reference) {
    this.reference = reference;
  }

  public boolean isInvertReference() {
    return invertReference;
  }

  public void setInvertReference(boolean invertReference) {
    this.invertReference = invertReference;
  }

  public String getNameOfReferenceVar() {
    return nameOfReferenceVar;
  }

  public void setNameOfReferenceVar(String nameOfReferenceVar) {
    this.nameOfReferenceVar = nameOfReferenceVar;
  }

  public boolean isStrictlyWithinHierarchy() {
    return strictlyWithinHierarchy;
  }

  public void setStrictlyWithinHierarchy(boolean strictlyWithinHierarchy) {
    this.strictlyWithinHierarchy = strictlyWithinHierarchy;
  }

  public String getNameOfExprType() {
    return nameOfExprType;
  }

  public void setNameOfExprType(String nameOfExprType) {
    this.nameOfExprType = nameOfExprType;
  }

  public boolean isInvertExprType() {
    return invertExprType;
  }

  public void setInvertExprType(boolean invertExprType) {
    this.invertExprType = invertExprType;
  }

  public boolean isExprTypeWithinHierarchy() {
    return exprTypeWithinHierarchy;
  }

  public void setExprTypeWithinHierarchy(boolean exprTypeWithinHierarchy) {
    this.exprTypeWithinHierarchy = exprTypeWithinHierarchy;
  }

  public boolean isWholeWordsOnly() {
    return wholeWordsOnly;
  }

  public void setWholeWordsOnly(boolean wholeWordsOnly) {
    this.wholeWordsOnly = wholeWordsOnly;
  }

  public String getNameOfFormalArgType() {
    return nameOfFormalArgType;
  }

  public void setNameOfFormalArgType(String nameOfFormalArgType) {
    this.nameOfFormalArgType = nameOfFormalArgType;
  }

  public boolean isInvertFormalType() {
    return invertFormalType;
  }

  public void setInvertFormalType(boolean invertFormalType) {
    this.invertFormalType = invertFormalType;
  }

  public boolean isFormalArgTypeWithinHierarchy() {
    return formalArgTypeWithinHierarchy;
  }

  public void setFormalArgTypeWithinHierarchy(boolean formalArgTypeWithinHierarchy) {
    this.formalArgTypeWithinHierarchy = formalArgTypeWithinHierarchy;
  }

  public boolean equals(Object o) {
    if (this == o) return true;
    if (!(o instanceof MatchVariableConstraint)) return false;
    if (!(super.equals(o))) return false;

    final MatchVariableConstraint matchVariableConstraint = (MatchVariableConstraint)o;

    if (exprTypeWithinHierarchy != matchVariableConstraint.exprTypeWithinHierarchy) return false;
    if (formalArgTypeWithinHierarchy != matchVariableConstraint.formalArgTypeWithinHierarchy) return false;
    if (greedy != matchVariableConstraint.greedy) return false;
    if (invertExprType != matchVariableConstraint.invertExprType) return false;
    if (invertFormalType != matchVariableConstraint.invertFormalType) return false;
    if (invertReadAccess != matchVariableConstraint.invertReadAccess) return false;
    if (invertReference != matchVariableConstraint.invertReference) return false;
    if (invertRegExp != matchVariableConstraint.invertRegExp) return false;
    if (invertWriteAccess != matchVariableConstraint.invertWriteAccess) return false;
    if (maxCount != matchVariableConstraint.maxCount) return false;
    if (minCount != matchVariableConstraint.minCount) return false;
    if (partOfSearchResults != matchVariableConstraint.partOfSearchResults) return false;
    if (readAccess != matchVariableConstraint.readAccess) return false;
    if (reference != matchVariableConstraint.reference) return false;
    if (strictlyWithinHierarchy != matchVariableConstraint.strictlyWithinHierarchy) return false;
    if (wholeWordsOnly != matchVariableConstraint.wholeWordsOnly) return false;
    if (withinHierarchy != matchVariableConstraint.withinHierarchy) return false;
    if (writeAccess != matchVariableConstraint.writeAccess) return false;
    if (!nameOfExprType.equals(matchVariableConstraint.nameOfExprType)) return false;
    if (!nameOfFormalArgType.equals(matchVariableConstraint.nameOfFormalArgType)) return false;
    if (!nameOfReferenceVar.equals(matchVariableConstraint.nameOfReferenceVar)) return false;
    if (!regExp.equals(matchVariableConstraint.regExp)) return false;
    if (!withinConstraint.equals(matchVariableConstraint.withinConstraint)) return false;
    if (!containsConstraint.equals(matchVariableConstraint.containsConstraint)) return false;
    if (invertWithinConstraint != matchVariableConstraint.invertWithinConstraint) return false;
    if (invertContainsConstraint != matchVariableConstraint.invertContainsConstraint) return false;

    return true;
  }

  public int hashCode() {
    int result;
    result = super.hashCode();
    result = 29 * result + regExp.hashCode();
    result = 29 * result + (invertRegExp ? 1 : 0);
    result = 29 * result + (withinHierarchy ? 1 : 0);
    result = 29 * result + (strictlyWithinHierarchy ? 1 : 0);
    result = 29 * result + (wholeWordsOnly ? 1 : 0);
    result = 29 * result + minCount;
    result = 29 * result + maxCount;
    result = 29 * result + (readAccess ? 1 : 0);
    result = 29 * result + (invertReadAccess ? 1 : 0);
    result = 29 * result + (writeAccess ? 1 : 0);
    result = 29 * result + (invertWriteAccess ? 1 : 0);
    result = 29 * result + (greedy ? 1 : 0);
    result = 29 * result + (reference ? 1 : 0);
    result = 29 * result + (invertReference ? 1 : 0);
    result = 29 * result + nameOfReferenceVar.hashCode();
    result = 29 * result + (partOfSearchResults ? 1 : 0);
    result = 29 * result + nameOfExprType.hashCode();
    result = 29 * result + (invertExprType ? 1 : 0);
    result = 29 * result + (exprTypeWithinHierarchy ? 1 : 0);
    result = 29 * result + nameOfFormalArgType.hashCode();
    result = 29 * result + (invertFormalType ? 1 : 0);
    result = 29 * result + (formalArgTypeWithinHierarchy ? 1 : 0);
    result = 29 * result + withinConstraint.hashCode();
    result = 29 * result + containsConstraint.hashCode();
    
    if (invertContainsConstraint) result = 29 * result + 1;
    if (invertWithinConstraint) result = 29 * result + 1;
    return result;
  }

  public void readExternal(Element element) {
    super.readExternal(element);
    Attribute attribute;

    attribute = element.getAttribute(REGEXP);
    if (attribute != null) {
      regExp = attribute.getValue();
    }

    attribute = element.getAttribute(NAME_OF_EXPRTYPE);
    if (attribute != null) {
      nameOfExprType = attribute.getValue();
    }

    attribute = element.getAttribute(NAME_OF_FORMALTYPE);
    if (attribute != null) {
      nameOfFormalArgType = attribute.getValue();
    }

    attribute = element.getAttribute(NAME_OF_REFEENCE_VAR);
    if (attribute != null) {
      nameOfReferenceVar = attribute.getValue();
    }

    attribute = element.getAttribute(WITHIN_HIERARCHY);
    if (attribute != null) {
      try {
        withinHierarchy = attribute.getBooleanValue();
      }
      catch (DataConversionException ex) {
      }
    }

    attribute = element.getAttribute(EXPRTYPE_WITHIN_HIERARCHY);
    if (attribute != null) {
      try {
        exprTypeWithinHierarchy = attribute.getBooleanValue();
      }
      catch (DataConversionException ex) {
      }
    }

    attribute = element.getAttribute(FORMALTYPE_WITHIN_HIERARCHY);
    if (attribute != null) {
      try {
        formalArgTypeWithinHierarchy = attribute.getBooleanValue();
      }
      catch (DataConversionException ex) {
      }
    }

    attribute = element.getAttribute(NEGATE_NAME_CONDITION);
    if (attribute != null) {
      try {
        invertRegExp = attribute.getBooleanValue();
      }
      catch (DataConversionException ex) {
      }
    }

    attribute = element.getAttribute(NEGATE_EXPRTYPE_CONDITION);
    if (attribute != null) {
      try {
        invertExprType = attribute.getBooleanValue();
      }
      catch (DataConversionException ex) {
      }
    }

    attribute = element.getAttribute(NEGATE_FORMALTYPE_CONDITION);
    if (attribute != null) {
      try {
        invertFormalType = attribute.getBooleanValue();
      }
      catch (DataConversionException ex) {
      }
    }

    attribute = element.getAttribute(NEGATE_READ_CONDITION);
    if (attribute != null) {
      try {
        invertReadAccess = attribute.getBooleanValue();
      }
      catch (DataConversionException ex) {
      }
    }

    attribute = element.getAttribute(NEGATE_WRITE_CONDITION);
    if (attribute != null) {
      try {
        invertWriteAccess = attribute.getBooleanValue();
      }
      catch (DataConversionException ex) {
      }
    }

    attribute = element.getAttribute(READ);
    if (attribute != null) {
      try {
        readAccess = attribute.getBooleanValue();
      }
      catch (DataConversionException ex) {
      }
    }

    attribute = element.getAttribute(WRITE);
    if (attribute != null) {
      try {
        writeAccess = attribute.getBooleanValue();
      }
      catch (DataConversionException ex) {
      }
    }

    attribute = element.getAttribute(TARGET);
    if (attribute != null) {
      try {
        partOfSearchResults = attribute.getBooleanValue();
      }
      catch (DataConversionException ex) {
      }
    }

    attribute = element.getAttribute(MIN_OCCURS);
    if (attribute != null) {
      try {
        minCount = attribute.getIntValue();
      }
      catch (DataConversionException ex) {
      }
    }

    attribute = element.getAttribute(MAX_OCCURS);
    if (attribute != null) {
      try {
        maxCount = attribute.getIntValue();
      }
      catch (DataConversionException ex) {
      }
    }

    attribute = element.getAttribute(WHOLE_WORDS_ONLY);
    if (attribute != null) {
      try {
        wholeWordsOnly = attribute.getBooleanValue();
      }
      catch (DataConversionException ex) {
      }
    }

    attribute = element.getAttribute(NEGATE_WITHIN_CONDITION);
    if (attribute != null) {
      try {
        invertWithinConstraint = attribute.getBooleanValue();
      } catch (DataConversionException ex) {}
    }

    attribute = element.getAttribute(NEGATE_CONTAINS_CONDITION);
    if (attribute != null) {
      try {
        invertContainsConstraint = attribute.getBooleanValue();
      } catch (DataConversionException ex) {}
    }

    attribute = element.getAttribute(CONTAINS_CONDITION);
    if(attribute != null) containsConstraint = attribute.getValue();

    attribute = element.getAttribute(WITHIN_CONDITION);
    if(attribute != null) withinConstraint = attribute.getValue();
  }

  public void writeExternal(Element element) {
    super.writeExternal(element);

    if (regExp.length() > 0) element.setAttribute(REGEXP,regExp);
    if (nameOfExprType.length() > 0) element.setAttribute(NAME_OF_EXPRTYPE,nameOfExprType);
    if (nameOfReferenceVar.length() > 0) element.setAttribute(NAME_OF_REFEENCE_VAR,nameOfReferenceVar);
    if (nameOfFormalArgType.length() > 0) element.setAttribute(NAME_OF_FORMALTYPE,nameOfFormalArgType);


    if (withinHierarchy) element.setAttribute(WITHIN_HIERARCHY,TRUE);
    if (exprTypeWithinHierarchy) element.setAttribute(EXPRTYPE_WITHIN_HIERARCHY,TRUE);
    if (formalArgTypeWithinHierarchy) element.setAttribute(FORMALTYPE_WITHIN_HIERARCHY,TRUE);

    if (minCount!=1) element.setAttribute(MIN_OCCURS,String.valueOf(minCount));
    if (maxCount!=1) element.setAttribute(MAX_OCCURS,String.valueOf(maxCount));
    if (partOfSearchResults) element.setAttribute(TARGET,TRUE);
    if (readAccess) element.setAttribute(READ,TRUE);
    if (writeAccess) element.setAttribute(WRITE,TRUE);

    if (invertRegExp) element.setAttribute(NEGATE_NAME_CONDITION,TRUE);
    if (invertExprType) element.setAttribute(NEGATE_EXPRTYPE_CONDITION,TRUE);
    if (invertFormalType) element.setAttribute(NEGATE_FORMALTYPE_CONDITION,TRUE);
    if (invertReadAccess) element.setAttribute(NEGATE_READ_CONDITION,TRUE);
    if (invertWriteAccess) element.setAttribute(NEGATE_WRITE_CONDITION,TRUE);

    if (wholeWordsOnly) element.setAttribute(WHOLE_WORDS_ONLY,TRUE);
    if (invertContainsConstraint) element.setAttribute(NEGATE_CONTAINS_CONDITION,TRUE);
    if (invertWithinConstraint) element.setAttribute(NEGATE_WITHIN_CONDITION,TRUE);
    element.setAttribute(WITHIN_CONDITION, withinConstraint);
    element.setAttribute(CONTAINS_CONDITION, containsConstraint);
  }

  public String getWithinConstraint() {
    return withinConstraint;
  }

  public void setWithinConstraint(final String withinConstraint) {
    this.withinConstraint = withinConstraint;
  }

  public String getContainsConstraint() {
    return containsConstraint;
  }

  public void setContainsConstraint(final String containsConstraint) {
    this.containsConstraint = containsConstraint;
  }

  public boolean isInvertContainsConstraint() {
    return invertContainsConstraint;
  }

  public void setInvertContainsConstraint(final boolean invertContainsConstraint) {
    this.invertContainsConstraint = invertContainsConstraint;
  }

  public boolean isInvertWithinConstraint() {
    return invertWithinConstraint;
  }

  public void setInvertWithinConstraint(final boolean invertWithinConstraint) {
    this.invertWithinConstraint = invertWithinConstraint;
  }

  public boolean isArtificial() {
    return artificial;
  }
}