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

COVERAGE SUMMARY FOR SOURCE FILE [CommutativeAnd.java]

nameclass, %method, %block, %line, %
CommutativeAnd.java100% (1/1)82%  (14/17)75%  (543/727)67%  (85.6/127)

COVERAGE BREAKDOWN BY CLASS AND METHOD

nameclass, %method, %block, %line, %
     
class CommutativeAnd100% (1/1)82%  (14/17)75%  (543/727)67%  (85.6/127)
CommutativeAnd (double, TimeUnit): void 0%   (0/1)0%   (0/10)0%   (0/3)
add (Predicate): CommutativeAnd 0%   (0/1)0%   (0/17)0%   (0/3)
map (int []): Extractor 0%   (0/1)0%   (0/27)0%   (0/4)
normalize (): Predicate 100% (1/1)64%  (140/220)57%  (27/47)
remove (Predicate): Predicate 100% (1/1)74%  (26/35)56%  (4/7)
compareTo (Extractor): ComparisonResult 100% (1/1)76%  (86/113)69%  (18/26)
$SWITCH_TABLE$com$hammurapi$extract$ComparisonResult$Type (): int [] 100% (1/1)88%  (85/97)87%  (0.9/1)
isContextDependent (): boolean 100% (1/1)89%  (17/19)75%  (3/4)
CommutativeAnd (double, TimeUnit, Iterable): void 100% (1/1)100% (24/24)100% (5/5)
CommutativeAnd (double, TimeUnit, Predicate []): void 100% (1/1)100% (29/29)100% (5/5)
addPart (Predicate): void 100% (1/1)100% (26/26)100% (5/5)
clone (): Object 100% (1/1)100% (13/13)100% (3/3)
extractInternal (Object, Map, Object []): Boolean 100% (1/1)100% (26/26)100% (4/4)
getCost (): double 100% (1/1)100% (32/32)100% (6/6)
getParts (): Set 100% (1/1)100% (4/4)100% (1/1)
parameterIndices (): Set 100% (1/1)100% (23/23)100% (4/4)
toString (): String 100% (1/1)100% (12/12)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 AND.
14 * @author Pavel Vlasov.
15 *
16 * @param <T>
17 */
18public class CommutativeAnd<T, C> extends ExtractorBase<T, Boolean, C> implements CommutativeCompositePredicate<T, C, CommutativeAnd<T,C>>, Serializable {
19        
20        private Set<Predicate<T, C>> parts = new HashSet<Predicate<T, C>>();
21        
22        public CommutativeAnd(double initialCost, TimeUnit costUnit) {
23                super(initialCost,costUnit);
24        }
25        
26        public CommutativeAnd(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 CommutativeAnd(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 CommutativeAnd) {
42                        for (Predicate<T, C> pp: ((CommutativeAnd<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 CommutativeAnd && parts.equals(((CommutativeAnd) otherPredicate).parts)) {
62                        return ComparisonResult.EQUAL_NM;
63                }
64                
65                boolean isTrue = true;
66                boolean isFalse = false;
67                for (Predicate<T, C> part: getParts()) {        
68                        ComparisonResult pcr = part.compareTo((Predicate<T, C>) False.getInstance());
69                        if (pcr.getType().equals(ComparisonResult.Type.EQUAL)) {
70                                isFalse = true;
71                                isTrue = false;
72                                break;                                
73                        } else if (!pcr.getType().equals(ComparisonResult.Type.OPPOSITE)) {
74                                isTrue = 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 MORE_RESTRICTIVE:
95                                        return ComparisonResult.MORE_RESTRICTIVE_NM;
96//                                case OPPOSITE:
97//                                case OPPOSITE_MORE_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 false;
110                        }
111                }
112                return true;
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                        CommutativeAnd<T, C> ret = (CommutativeAnd<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                Predicate<T, C>[] pa = getParts().toArray(new Predicate[getParts().size()]);
158                Z: for (int i=0; i<pa.length; ++i) {
159                        for (int j=0; j<pa.length; ++j) {
160                                if (j!=i && pa[i]!=null && pa[j]!=null) {
161                                        ComparisonResult pcr1 = pa[i].compareTo(pa[j]);
162                                        if (pcr1.isOneToOneMapping()) {
163                                                switch (pcr1.getType()) {
164                                                case EQUAL:
165                                                case LESS_RESTRICTIVE:
166                                                        pa[j]=null;
167                                                        continue;
168                                                case OPPOSITE:
169                                                case OPPOSITE_LESS_RESTRICTIVE:
170                                                        return False.getInstance();
171                                                }
172                                        }
173                                        
174                                        ComparisonResult pcr2 = pa[j].compareTo(pa[i]);
175                                        if (pcr2.isOneToOneMapping()) {
176                                                switch (pcr2.getType()) {
177                                                case EQUAL:
178                                                case LESS_RESTRICTIVE:
179                                                        pa[i]=null;
180                                                        continue Z;
181                                                case OPPOSITE:
182                                                case OPPOSITE_LESS_RESTRICTIVE:
183                                                        return False.getInstance();
184                                                }
185                                        }                                        
186                                }
187                        }
188                }
189                
190                int pc = 0; 
191                for (Predicate<T, C> part: pa) {
192                        if (part!=null) {
193                                ++pc;
194                        }
195                }
196                
197                if (pc==0) {
198                        return True.getInstance();
199                }
200                
201                if (pc==1) {
202                        for (Predicate<T, C> part: pa) {
203                                if (part!=null) {
204                                        if (part instanceof CompositePredicate) {
205                                                ((CompositePredicate) part).normalize();
206                                        }
207                                        return part;
208                                }
209                        }
210                }
211                
212                if (pc!=pa.length) {
213                        CommutativeAnd<T, C> ret = new CommutativeAnd<T, C>(cost, costUnit);
214                        for (Predicate<T, C> part: pa) {
215                                if (part!=null) {
216                                        ret.addPart(part);
217                                }
218                        }
219                        return ret;
220                }
221                
222                return this;
223        }
224 
225        public boolean isContextDependent() {
226                for (Predicate<T, C> part: getParts()) {
227                        if (part.isContextDependent()) {
228                                return true;
229                        }
230                }
231                return false;
232        }
233        
234        @Override
235        public String toString() {
236                return getClass().getName()+getParts();
237        }
238        
239        @Override
240        public double getCost() {
241                if (cost==0 && costUnit==null) {
242                        double ret = 0;
243                        for (Predicate<T,C> part: parts) {
244                                ret+=part.getCost();
245                        }
246                        return ret;
247                }
248                return super.getCost();
249        }
250        
251 
252        @Override
253        public Extractor<T, Boolean, C> map(int[] map) {
254                CommutativeAnd<T,C> ret = new CommutativeAnd<T, C>(initialCost, costUnit);
255                for (Predicate<T,C> part: parts) {
256                        ret.addPart(MappedPredicate.mapPredicate(part, map));
257                }
258                return ret;
259        }
260        
261        @Override
262        public Object clone() throws CloneNotSupportedException {
263                @SuppressWarnings("unchecked")
264                CommutativeAnd<T,C> ret = (CommutativeAnd<T, C>) super.clone();
265                ret.parts = new HashSet<Predicate<T,C>>(parts); 
266                return ret;
267        }
268        
269        @Override
270        public CommutativeAnd<T, C> add(Predicate<T, C> part) {
271                CommutativeAnd<T, C> ret = new CommutativeAnd<T, C>(initialCost, costUnit, parts);
272                ret.parts.add(part);
273                return ret;
274        }
275}

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