001: /*
002: * <copyright>
003: *
004: * Copyright 1997-2004 BBNT Solutions, LLC
005: * under sponsorship of the Defense Advanced Research Projects
006: * Agency (DARPA).
007: *
008: * You can redistribute this software and/or modify it under the
009: * terms of the Cougaar Open Source License as published on the
010: * Cougaar Open Source Website (www.cougaar.org).
011: *
012: * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
013: * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
014: * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
015: * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
016: * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
017: * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
018: * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
019: * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
020: * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
021: * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
022: * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
023: *
024: * </copyright>
025: */
026:
027: package org.cougaar.lib.contract.lang;
028:
029: import org.cougaar.lib.contract.Operator;
030:
031: import org.cougaar.lib.contract.lang.compare.*;
032:
033: import org.cougaar.lib.contract.lang.parser.*;
034:
035: import org.w3c.dom.Document;
036: import org.w3c.dom.Element;
037: import org.w3c.dom.Node;
038:
039: /**
040: * Base (abstract) implementation of <code>Op</code>.
041: * <p>
042: * @see Op
043: */
044: public abstract class OpImpl implements Op {
045:
046: public OpImpl() {
047: }
048:
049: /**
050: * Parser additions to <code>org.cougaar.lib.contract.Operator</code>
051: */
052: public abstract int getID();
053:
054: public abstract Op parse(final OpParser p) throws ParseException;
055:
056: /**
057: * Most <code>Op</code>s return boolean.
058: */
059: public boolean isReturnBoolean() {
060: return true;
061: }
062:
063: /**
064: * Most <code>Op</code>s return boolean.
065: */
066: public Class getReturnClass() {
067: return Boolean.TYPE;
068: }
069:
070: /**
071: * Subclass should redefine either <tt>operate</tt> and/or
072: * <tt>execute</tt>!
073: */
074: public Object operate(final Object o) {
075: throw new UnsupportedOperationException();
076: }
077:
078: /**
079: * Subclass should redefine either <tt>operate</tt> and/or
080: * <tt>execute</tt>!
081: */
082: public boolean execute(final Object o) {
083: throw new UnsupportedOperationException();
084: }
085:
086: /**
087: * Sets a constant value in the <code>Op</code>, which is accessed
088: * using "(get key)".
089: * <p>
090: * As an artifact of the tree structure, <code>Op</code> implementations
091: * need to pass this method down to sub-<code>Op</code>s:
092: * <code>
093: * for all Op fields f0..fn, f.setConst(key, val);
094: * </code>
095: * to react the GetOps, which actually uses the values.
096: */
097: public void setConst(final String key, final Object val) {
098: }
099:
100: /**
101: * <tt>allows</tt>(<code>Operator</code>) is computed by
102: * <code>org.cougaar.lib.contract.lang.compare.Allow</code>.
103: */
104: public boolean allows(final Operator oper) {
105: //return Allow.compute(this, oper);
106: return (Imply.compute(this , oper) || Imply.compute(oper, this ));
107: }
108:
109: /**
110: * <tt>implies</tt>(<code>Operator</code>) is computed by
111: * <code>org.cougaar.lib.contract.lang.compare.Imply</code>.
112: */
113: public boolean implies(final Operator oper) {
114: return Imply.compute(this , oper);
115: }
116:
117: /**
118: * Equivalent to
119: * <tt>oper.implies(this)</tt>.
120: */
121: public boolean impliedBy(final Operator oper) {
122: return Imply.compute(oper, this );
123: }
124:
125: /**
126: * <tt>equals</tt>(<code>Operator</code>) is computed by
127: * <code>org.cougaar.lib.contract.lang.compare.Equal</code>.
128: */
129: public boolean equals(final Operator oper) {
130: return Equal.compute(this , oper);
131: }
132:
133: public final boolean equals(final Object o) {
134: return ((o instanceof Operator) ? Equal.compute(this ,
135: (Operator) o) : false);
136: }
137:
138: public final String toString() {
139: return toString(DEFAULT_STYLE);
140: }
141:
142: public final String toString(int style) {
143: StringVisitor strVis;
144: if ((style & PAREN_FLAG) != 0) {
145: strVis = ParenParser.getStringVisitor();
146: } else if ((style & XML_FLAG) != 0) {
147: strVis = XMLParser.getStringVisitor();
148: } else {
149: throw new IllegalArgumentException(
150: "Unknown Operator.toString style: " + style);
151: }
152: strVis.initialize();
153: strVis.setVerbose((style & VERBOSE_FLAG) != 0);
154: strVis.setPrettyPrint((style & PRETTY_FLAG) != 0);
155: accept(strVis);
156: strVis.visitEndOfTree();
157: return strVis.toString();
158: }
159:
160: public final Element getXML(Document doc, final int style) {
161: XMLBuilderVisitor xmlVis = XMLParser.getXMLVisitor(doc);
162: xmlVis.initialize();
163: xmlVis.setVerbose((style & VERBOSE_FLAG) != 0);
164: accept(xmlVis);
165: xmlVis.visitEndOfTree();
166: return xmlVis.getResult();
167: }
168:
169: public final Element getXML(Document doc) {
170: return getXML(doc, DEFAULT_STYLE);
171: }
172:
173: public abstract void accept(TreeVisitor visitor);
174: }
|