EMMA Coverage Report (generated Thu Jan 20 11:39:44 EST 2011)
[all classes][com.hammurapi.extract]

COVERAGE SUMMARY FOR SOURCE FILE [Or.java]

nameclass, %method, %block, %line, %
Or.java0%   (0/1)0%   (0/17)0%   (0/727)0%   (0/127)

COVERAGE BREAKDOWN BY CLASS AND METHOD

nameclass, %method, %block, %line, %
     
class Or0%   (0/1)0%   (0/17)0%   (0/727)0%   (0/127)
$SWITCH_TABLE$com$hammurapi$extract$ComparisonResult$Type (): int [] 0%   (0/1)0%   (0/97)0%   (0/1)
Or (double, TimeUnit): void 0%   (0/1)0%   (0/10)0%   (0/3)
Or (double, TimeUnit, Iterable): void 0%   (0/1)0%   (0/24)0%   (0/5)
Or (double, TimeUnit, Predicate []): void 0%   (0/1)0%   (0/29)0%   (0/5)
add (Predicate): Or 0%   (0/1)0%   (0/17)0%   (0/3)
addPart (Predicate): void 0%   (0/1)0%   (0/26)0%   (0/5)
clone (): Object 0%   (0/1)0%   (0/13)0%   (0/3)
compareTo (Extractor): ComparisonResult 0%   (0/1)0%   (0/113)0%   (0/26)
extractInternal (Object, Map, Object []): Boolean 0%   (0/1)0%   (0/26)0%   (0/4)
getCost (): double 0%   (0/1)0%   (0/32)0%   (0/6)
getParts (): List 0%   (0/1)0%   (0/4)0%   (0/1)
isContextDependent (): boolean 0%   (0/1)0%   (0/19)0%   (0/4)
map (int []): Extractor 0%   (0/1)0%   (0/27)0%   (0/4)
normalize (): Predicate 0%   (0/1)0%   (0/220)0%   (0/47)
parameterIndices (): Set 0%   (0/1)0%   (0/23)0%   (0/4)
remove (Predicate): Predicate 0%   (0/1)0%   (0/35)0%   (0/7)
toString (): String 0%   (0/1)0%   (0/12)0%   (0/1)

1package com.hammurapi.extract;
2 
3import java.io.Serializable;
4import java.util.ArrayList;
5import java.util.Collections;
6import java.util.List;
7import java.util.Map;
8import java.util.Set;
9import java.util.TreeSet;
10import java.util.concurrent.TimeUnit;
11 
12 
13/**
14 * Non-commutative OR.
15 * @author Pavel Vlasov.
16 *
17 * @param <T>
18 */
19public class Or<T, C> extends ExtractorBase<T, Boolean, C> implements CompositePredicate<T, List<Predicate<T, C>>, C, Or<T,C>>, Serializable {
20        
21        private List<Predicate<T, C>> parts = new ArrayList<Predicate<T, C>>();
22        
23        public Or(double initialCost, TimeUnit costUnit) {
24                super(initialCost, costUnit);
25        }
26        
27        public Or(double initialCost, TimeUnit costUnit, Predicate<T,C>... parts) {
28                super(initialCost, costUnit);
29                for (Predicate<T,C> part: parts) {
30                        addPart(part);
31                }
32        }        
33        
34        public Or(double initialCost, TimeUnit costUnit, Iterable<Predicate<T,C>> parts) {
35                super(initialCost, costUnit);
36                for (Predicate<T,C> part: parts) {
37                        addPart(part);
38                }
39        }        
40        
41        private void addPart(Predicate<T, C> part) {
42                if (part instanceof Or) {
43                        for (Predicate<T, C> pp: ((Or<T, C>) part).getParts()) {
44                                addPart(pp);
45                        }
46                } else {
47                        parts.add(part);
48                }
49        }
50 
51        public List<Predicate<T, C>> getParts() {
52                return Collections.unmodifiableList(parts);
53        }
54 
55        @Override
56        @SuppressWarnings("unchecked")
57        public ComparisonResult compareTo(Extractor<T, Boolean, C> otherPredicate) {
58                if (getParts().isEmpty()) {
59                        return True.getInstance().compareTo((Extractor<Object, Boolean, Object>) otherPredicate);
60                }
61                
62                if (otherPredicate instanceof Or && parts.equals(((Or) otherPredicate).parts)) {
63                        return ComparisonResult.EQUAL_NM;
64                }
65                
66                boolean isTrue = false;
67                boolean isFalse = true;
68                for (Predicate<T, C> part: getParts()) {        
69                        ComparisonResult pcr = part.compareTo((Predicate<T, C>) True.getInstance());
70                        if (pcr.getType().equals(ComparisonResult.Type.EQUAL)) {
71                                isTrue = true;
72                                isFalse = false;
73                                break;                                
74                        } else if (!pcr.getType().equals(ComparisonResult.Type.OPPOSITE)) {
75                                isFalse = false;
76                        }                                                
77                }
78                
79                if (isTrue) {
80                        return otherPredicate.compareTo((Predicate<T, C>) True.getInstance());
81                }
82                
83                if (isFalse) {
84                        return otherPredicate.compareTo((Predicate<T, C>) False.getInstance());
85                }
86                
87                if (getParts().size()==1) {
88                        return getParts().iterator().next().compareTo(otherPredicate);
89                }
90                for (Predicate<T, C> part: getParts()) {        
91                        ComparisonResult pcr = part.compareTo(otherPredicate);
92                        if (pcr.isOneToOneMapping()) {
93                                switch (pcr.getType()) {
94                                case EQUAL:
95                                case LESS_RESTRICTIVE:
96                                        return ComparisonResult.LESS_RESTRICTIVE_NM;
97//                                case OPPOSITE:
98//                                case OPPOSITE_LESS_RESTRICTIVE:
99//                                        return ComparisonResult.OPPOSITE_MORE_RESTRICTIVE_NM;
100                                }
101                        }
102                }
103                
104                return super.compareTo(otherPredicate);
105        }
106 
107        protected Boolean extractInternal(
108                        C context,
109                        Map<C, Map<Extractor<T, ? super Boolean, C>, ? super Boolean>> cache,
110                        T... obj) {
111                
112                for (Predicate<T, C> part: parts) {
113                        if (part.extract(context, cache, obj)) {
114                                return true;
115                        }
116                }
117                return false;
118        }
119 
120        public Set<Integer> parameterIndices() {
121                Set<Integer> ret = new TreeSet<Integer>();
122                for (Predicate<T, C> part: parts) {
123                        ret.addAll(part.parameterIndices());
124                }
125                return ret;
126        }
127 
128 
129        @SuppressWarnings("unchecked")
130        public Predicate<T, C> remove(Predicate<T, C> part) {
131                if (!parts.contains(part)) {
132                        return this;
133                }
134                try {
135                        Or<T, C> ret = (Or<T, C>) clone();
136                        ret.parts.remove(part);
137                        return ret.parts.size()==1 ? ret.parts.get(0) : ret;
138                } catch (CloneNotSupportedException e) {
139                        throw new ExtractorException(e);
140                }
141        }
142 
143        @SuppressWarnings("unchecked")
144        public Predicate<T, C> normalize() {
145                if (getParts().isEmpty()) {
146                        return True.getInstance();
147                }
148                if (getParts().size()==1) {
149                        Predicate<T, C> ret = getParts().get(0);
150                        if (ret instanceof CompositePredicate) {
151                                ((CompositePredicate) ret).normalize();
152                        }
153                        return ret;
154                }
155                ComparisonResult cr = compareTo((Predicate<T, C>) True.getInstance());
156                if (cr.getType().equals(ComparisonResult.Type.EQUAL)) {
157                        return True.getInstance();
158                }
159                if (cr.getType().equals(ComparisonResult.Type.OPPOSITE)) {
160                        return False.getInstance();
161                }
162                Predicate<T, C>[] pa = getParts().toArray(new Predicate[getParts().size()]);
163                Z: for (int i=0; i<pa.length; ++i) {
164                        for (int j=0; j<pa.length; ++j) {
165                                if (j!=i && pa[i]!=null && pa[j]!=null) {
166                                        ComparisonResult pcr1 = pa[i].compareTo(pa[j]);
167                                        if (pcr1.isOneToOneMapping()) {
168                                                switch (pcr1.getType()) {
169                                                case EQUAL:
170                                                case MORE_RESTRICTIVE:
171                                                        pa[j]=null;
172                                                        continue;
173                                                case OPPOSITE:
174                                                case OPPOSITE_MORE_RESTRICTIVE:
175                                                        return True.getInstance();
176                                                }
177                                        }
178                                        
179                                        ComparisonResult pcr2 = pa[j].compareTo(pa[i]);
180                                        if (pcr2.isOneToOneMapping()) {
181                                                switch (pcr2.getType()) {
182                                                case EQUAL:
183                                                case MORE_RESTRICTIVE:
184                                                        pa[i]=null;
185                                                        continue Z;
186                                                case OPPOSITE:
187                                                case OPPOSITE_MORE_RESTRICTIVE:
188                                                        return True.getInstance();
189                                                }
190                                        }                                        
191                                }
192                        }
193                }
194                
195                int pc = 0; 
196                for (Predicate<T, C> part: pa) {
197                        if (part!=null) {
198                                ++pc;
199                        }
200                }
201                
202                if (pc==0) {
203                        return True.getInstance();
204                }
205                
206                if (pc==1) {
207                        for (Predicate<T, C> part: pa) {
208                                if (part!=null) {
209                                        if (part instanceof CompositePredicate) {
210                                                ((CompositePredicate) part).normalize();
211                                        }
212                                        return part;
213                                }
214                        }
215                }
216                
217                if (pc!=pa.length) {
218                        Or<T, C> ret = new Or<T, C>(cost, costUnit);
219                        for (Predicate<T, C> part: pa) {
220                                if (part!=null) {
221                                        ret.addPart(part);
222                                }
223                        }
224                        return ret;
225                }
226                                
227                return this;
228        }
229 
230        public boolean isContextDependent() {
231                for (Predicate<T, C> part: getParts()) {
232                        if (part.isContextDependent()) {
233                                return true;
234                        }
235                }
236                return false;
237        }
238        
239        @Override
240        public String toString() {
241                return getClass().getName()+getParts();
242        }
243        
244        @Override
245        public double getCost() {
246                if (cost==0 && costUnit==null) {
247                        double ret = 0;
248                        for (Predicate<T,C> part: parts) {
249                                ret+=part.getCost();
250                        }
251                        return ret;
252                }
253                return super.getCost();
254        }
255        
256 
257        @Override
258        public Extractor<T, Boolean, C> map(int[] map) {
259                Or<T,C> ret = new Or<T, C>(initialCost, costUnit);
260                for (Predicate<T,C> part: parts) {
261                        ret.addPart(MappedPredicate.mapPredicate(part, map));
262                }
263                return ret;
264        }
265        
266        @Override
267        public Object clone() throws CloneNotSupportedException {
268                @SuppressWarnings("unchecked")
269                Or<T,C> ret = (Or<T, C>) super.clone();
270                ret.parts = new ArrayList<Predicate<T,C>>(parts); 
271                return ret;
272        }
273        
274        @Override
275        public Or<T, C> add(Predicate<T, C> part) {
276                Or<T, C> ret = new Or<T, C>(initialCost, costUnit, parts);
277                ret.parts.add(part);
278                return ret;
279        }
280}

[all classes][com.hammurapi.extract]
EMMA 2.0.5312 EclEmma Fix 2 (C) Vladimir Roubtsov