SubstFuncVo.java
001 /* This file is part of the project "Hilbert II" - http://www.qedeq.org
002  *
003  * Copyright 2000-2011,  Michael Meyling <mime@qedeq.org>.
004  *
005  * "Hilbert II" is free software; you can redistribute
006  * it and/or modify it under the terms of the GNU General Public
007  * License as published by the Free Software Foundation; either
008  * version 2 of the License, or (at your option) any later version.
009  *
010  * This program is distributed in the hope that it will be useful,
011  * but WITHOUT ANY WARRANTY; without even the implied warranty of
012  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
013  * GNU General Public License for more details.
014  */
015 
016 package org.qedeq.kernel.se.dto.module;
017 
018 import org.qedeq.base.utility.EqualsUtility;
019 import org.qedeq.kernel.se.base.list.Element;
020 import org.qedeq.kernel.se.base.module.SubstFunc;
021 
022 
023 /**
024  * Usage of rule for substitute function variable.
025  *
026  @author  Michael Meyling
027  */
028 public class SubstFuncVo implements SubstFunc {
029 
030     /** Reference to previously proven formula. */
031     private String reference;
032 
033     /** Function variable that will be substituted. */
034     private Element functionVariable;
035 
036     /** Replacement term. */
037     private Element substituteTerm;
038 
039     /**
040      * Constructs an reason.
041      *
042      @param   reference                   Reference to a valid formula.
043      @param   functionVariable            Function variable that will be substituted.
044      @param   substituteFormula           Replacement term.
045      */
046 
047     public SubstFuncVo(final String reference, final Element functionVariable,
048             final Element substituteFormula) {
049         this.reference = reference;
050         this.functionVariable = functionVariable;
051         this.substituteTerm = substituteFormula;
052     }
053 
054     /**
055      * Default constructor.
056      */
057     public SubstFuncVo() {
058         // nothing to do
059     }
060 
061     public SubstFunc getSubstFunc() {
062         return this;
063     }
064 
065     public String getReference() {
066         return reference;
067     }
068 
069     /**
070      * Set formula reference.
071      *
072      @param   reference   Reference to formula.
073      */
074     public void setReference(final String reference) {
075         this.reference = reference;
076     }
077 
078     public String[] getReferences() {
079         if (reference == null || reference.length() == 0) {
080             return new String[] {};
081         else {
082             return new String[] {reference };
083         }
084     }
085 
086     public Element getFunctionVariable() {
087         return functionVariable;
088     }
089 
090     /**
091      * Set function variable that will be substituted.
092      *
093      @param   functionVariable  Function variable that will be replaced.
094      */
095     public void setFunctionVariable(final Element functionVariable) {
096         this.functionVariable = functionVariable;
097     }
098 
099     public Element getSubstituteTerm() {
100         return substituteTerm;
101     }
102 
103     /**
104      * Set substitution term.
105      *
106      @param   substituteTerm  New term.
107      */
108     public void setSubstituteTerm(final Element substituteTerm) {
109         this.substituteTerm = substituteTerm;
110     }
111 
112     public String getName() {
113         return "SubstFun";
114     }
115 
116     public boolean equals(final Object obj) {
117         if (!(obj instanceof SubstFuncVo)) {
118             return false;
119         }
120         final SubstFuncVo other = (SubstFuncVoobj;
121         return EqualsUtility.equals(reference, other.reference)
122             && EqualsUtility.equals(functionVariable, other.functionVariable)
123             && EqualsUtility.equals(substituteTerm, other.substituteTerm);
124     }
125 
126     public int hashCode() {
127         return (reference != null ? reference.hashCode() 0)
128             (functionVariable != null ^ functionVariable.hashCode() 0)
129             (substituteTerm != null ^ substituteTerm.hashCode() 0);
130     }
131 
132     public String toString() {
133         StringBuffer result = new StringBuffer();
134         result.append("SubstFree");
135         if (reference != null || functionVariable != null
136                 || substituteTerm != null) {
137             result.append(" (");
138             boolean w = false;
139             if (reference != null) {
140                 result.append(reference);
141                 w = true;
142             }
143             if (functionVariable != null) {
144                 if (w) {
145                     result.append(", ");
146                 }
147                 result.append(functionVariable);
148                 w = true;
149             }
150             if (substituteTerm != null) {
151                 if (w) {
152                     result.append(", ");
153                 }
154                 result.append("by ");
155                 result.append(substituteTerm);
156                 w = true;
157             }
158             result.append(")");
159         }
160         return result.toString();
161     }
162 
163 }