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

COVERAGE SUMMARY FOR SOURCE FILE [CommutativeOr.java]

nameclass, %method, %block, %line, %
CommutativeOr.java100% (1/1)41%  (7/17)46%  (332/727)39%  (50.1/127)

COVERAGE BREAKDOWN BY CLASS AND METHOD

nameclass, %method, %block, %line, %
     
class CommutativeOr100% (1/1)41%  (7/17)46%  (332/727)39%  (50.1/127)
CommutativeOr (double, TimeUnit): void 0%   (0/1)0%   (0/10)0%   (0/3)
CommutativeOr (double, TimeUnit, Predicate []): void 0%   (0/1)0%   (0/29)0%   (0/5)
add (Predicate): CommutativeOr 0%   (0/1)0%   (0/17)0%   (0/3)
clone (): Object 0%   (0/1)0%   (0/13)0%   (0/3)
extractInternal (Object, Map, Object []): Boolean 0%   (0/1)0%   (0/26)0%   (0/4)
isContextDependent (): boolean 0%   (0/1)0%   (0/19)0%   (0/4)
map (int []): Extractor 0%   (0/1)0%   (0/27)0%   (0/4)
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)
getCost (): double 100% (1/1)25%  (8/32)27%  (1.6/6)
addPart (Predicate): void 100% (1/1)35%  (9/26)60%  (3/5)
normalize (): Predicate 100% (1/1)57%  (125/220)49%  (23/47)
compareTo (Extractor): ComparisonResult 100% (1/1)68%  (77/113)63%  (16.3/26)
$SWITCH_TABLE$com$hammurapi$extract$ComparisonResult$Type (): int [] 100% (1/1)88%  (85/97)87%  (0.9/1)
CommutativeOr (double, TimeUnit, Iterable): void 100% (1/1)100% (24/24)100% (5/5)
getParts (): Set 100% (1/1)100% (4/4)100% (1/1)

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

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