View Javadoc

1   /*
2   * The contents of this file are subject to the BT "ZEUS" Open Source 
3   * Licence (L77741), Version 1.0 (the "Licence"); you may not use this file 
4   * except in compliance with the Licence. You may obtain a copy of the Licence
5   * from $ZEUS_INSTALL/licence.html or alternatively from
6   * http://www.labs.bt.com/projects/agents/zeus/licence.htm
7   * 
8   * Except as stated in Clause 7 of the Licence, software distributed under the
9   * Licence is distributed WITHOUT WARRANTY OF ANY KIND, either express or 
10  * implied. See the Licence for the specific language governing rights and 
11  * limitations under the Licence.
12  * 
13  * The Original Code is within the package zeus.*.
14  * The Initial Developer of the Original Code is British Telecommunications
15  * public limited company, whose registered office is at 81 Newgate Street, 
16  * London, EC1A 7AJ, England. Portions created by British Telecommunications 
17  * public limited company are Copyright 1996-9. All Rights Reserved.
18  * 
19  * THIS NOTICE MUST BE INCLUDED ON ANY COPY OF THIS FILE
20  */
21  
22  
23  
24  package zeus.concepts.fn;
25  
26  import java.util.*;
27  import zeus.util.*;
28  import zeus.concepts.*;
29  
30  public class LogicalOrFn extends LogicalFn {
31     protected ValueFunction[] args = new ValueFunction[2];
32  
33     static final String[] legal_operands = {
34        "zeus.concepts.fn.DefinedFn",
35        "zeus.concepts.fn.MethodCallFn"
36     };
37  
38     public LogicalOrFn(ValueFunction lhs, ValueFunction rhs) 
39        throws IllegalArgumentException {
40  
41        super(LOR,4);
42        String lhs_type = lhs.getClass().getName();
43        String rhs_type = rhs.getClass().getName();
44  
45        if ( (!(lhs instanceof LogicalFn) && !Misc.member(lhs_type,legal_operands)) ||
46             (!(rhs instanceof LogicalFn) && !Misc.member(rhs_type,legal_operands)) )
47           throw new IllegalArgumentException("Illegal operand type in function  \'" +
48                                              lhs + " || " + rhs + "\'");
49        args[0] = lhs;
50        args[1] = rhs;
51     }
52     public ValueFunction mirror() {
53        return new LogicalOrFn(args[0].mirror(),args[1].mirror());
54     }
55  
56     public String toString() {
57        return "(" + args[0] + " || " + args[1] + ")";
58     }
59     ValueFunction simplify() {
60        ValueFunction a, b;
61        a = args[0].simplify();
62        b = args[1].simplify();
63        return (a != args[0] || b != args[1])
64               ? new LogicalOrFn(a,b) : this;
65     }
66     Object getArg(int position) {
67        Assert.notFalse(position >= 0 && position <= args.length);
68        return args[position];
69     }
70     public boolean references(ValueFunction var) {
71        return args[0].references(var) || args[1].references(var);
72     }
73     public Vector variables() {
74        return Misc.union(args[0].variables(),args[1].variables());
75     }
76     public boolean isDeterminate() {
77        return args[0].isDeterminate() && args[1].isDeterminate();
78     }
79     ValueFunction normalize() {
80        ValueFunction a, b;
81        a = args[0].normalize();
82        b = args[1].normalize();
83        return (a != args[0] || b != args[1] )
84               ? new LogicalOrFn(a,b) : this;
85     }
86     public ValueFunction resolve(ResolutionContext c, Bindings b) {
87        ValueFunction x = args[0].resolve(c,b);
88        ValueFunction y = args[1].resolve(c,b);
89        return (new LogicalOrFn(x,y)).evaluationFn();
90     }
91  
92     public int evaluate() {
93        ValueFunction fn = evaluationFn();
94        if ( fn == this ) return UNKNOWN;
95        else if ( fn == BoolFn.trueFn ) return TRUE;
96        else return FALSE;
97     }
98  
99     public ValueFunction evaluationFn() {
100       if ( !isDeterminate() ) return this;
101 
102       BoolFn a, b;
103       a = (BoolFn) args[0].evaluationFn();
104       b = (BoolFn) args[1].evaluationFn();
105 
106       return a.equals(BoolFn.trueFn) || b.equals(BoolFn.trueFn)
107              ? BoolFn.trueFn : BoolFn.falseFn;
108    }
109 
110    public ValueFunction duplicate(DuplicationTable table) {
111       return new LogicalOrFn(args[0].duplicate(table),args[1].duplicate(table));
112    }
113    public boolean equals(Object any) {
114       if ( !(any instanceof LogicalOrFn) ) return false;
115       LogicalOrFn fn = (LogicalOrFn)any;
116       ValueFunction a = this.simplify();
117       ValueFunction b = fn.simplify();
118       return ((ValueFunction)a.getArg(0)).equals((ValueFunction)b.getArg(0)) &&
119              ((ValueFunction)a.getArg(1)).equals((ValueFunction)b.getArg(1));
120    }
121 }