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

COVERAGE SUMMARY FOR SOURCE FILE [And.java]

nameclass, %method, %block, %line, %
And.java100% (1/1)94%  (16/17)77%  (558/727)69%  (87.2/127)

COVERAGE BREAKDOWN BY CLASS AND METHOD

nameclass, %method, %block, %line, %
     
class And100% (1/1)94%  (16/17)77%  (558/727)69%  (87.2/127)
add (Predicate): And 0%   (0/1)0%   (0/17)0%   (0/3)
normalize (): Predicate 100% (1/1)57%  (125/220)49%  (23/47)
compareTo (Extractor): ComparisonResult 100% (1/1)70%  (79/113)67%  (17.3/26)
remove (Predicate): Predicate 100% (1/1)77%  (27/35)57%  (4/7)
$SWITCH_TABLE$com$hammurapi$extract$ComparisonResult$Type (): int [] 100% (1/1)88%  (85/97)87%  (0.9/1)
getCost (): double 100% (1/1)91%  (29/32)83%  (5/6)
And (double, TimeUnit): void 100% (1/1)100% (10/10)100% (3/3)
And (double, TimeUnit, Iterable): void 100% (1/1)100% (24/24)100% (5/5)
And (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)
getParts (): List 100% (1/1)100% (4/4)100% (1/1)
isContextDependent (): boolean 100% (1/1)100% (19/19)100% (4/4)
map (int []): Extractor 100% (1/1)100% (27/27)100% (4/4)
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.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 AND.
15 * @author Pavel Vlasov.
16 *
17 * @param <T>
18 */
19public class And<T, C> extends ExtractorBase<T, Boolean, C> implements CompositePredicate<T, List<Predicate<T, C>>, C, And<T,C>>, Serializable, Cloneable {
20        
21        private List<Predicate<T, C>> parts = new ArrayList<Predicate<T, C>>();
22                
23        public And(double initialCost, TimeUnit costUnit) {
24                super(initialCost, costUnit);
25        }
26        
27        public And(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 And(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 And) {
43                        for (Predicate<T, C> pp: ((And<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 And && parts.equals(((And) otherPredicate).parts)) {
63                        return ComparisonResult.EQUAL_NM;
64                }
65                                
66                boolean isTrue = true;
67                boolean isFalse = false;
68                for (Predicate<T, C> part: getParts()) {        
69                        ComparisonResult pcr = part.compareTo((Predicate<T, C>) False.getInstance());                        
70                        if (pcr.getType().equals(ComparisonResult.Type.EQUAL)) {
71                                isFalse = true;
72                                isTrue = false;
73                                break;                                
74                        } else if (!pcr.getType().equals(ComparisonResult.Type.OPPOSITE)) {
75                                isTrue = 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().get(0).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 MORE_RESTRICTIVE:
96                                        return ComparisonResult.MORE_RESTRICTIVE_NM;
97//                                case OPPOSITE:
98//                                case OPPOSITE_MORE_RESTRICTIVE:
99//                                        return ComparisonResult.OPPOSITE_MORE_RESTRICTIVE_NM;
100                                }
101                        }
102                }
103                
104                return super.compareTo(otherPredicate);
105        }
106 
107        protected Boolean extractInternal(C context, Map<C, Map<Extractor<T, ? super Boolean, C>, ? super Boolean>> cache, T... obj) {
108                for (Predicate<T, C> part: parts) {
109                        if (!part.extract(context, cache, obj)) {
110                                return false;
111                        }
112                }
113                return true;
114        }
115 
116        public Set<Integer> parameterIndices() {
117                Set<Integer> ret = new TreeSet<Integer>();
118                for (Predicate<T, C> part: parts) {
119                        ret.addAll(part.parameterIndices());
120                }
121                return ret;
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                        And<T, C> ret = (And<T, C>) clone();
131                        ret.parts.remove(part);
132                        return ret.parts.size()==1 ? ret.parts.get(0) : 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().get(0);                        
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 LESS_RESTRICTIVE:
167                                                        pa[j]=null;
168                                                        continue;
169                                                case OPPOSITE:
170                                                case OPPOSITE_LESS_RESTRICTIVE:
171                                                        return False.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 LESS_RESTRICTIVE:
180                                                        pa[i]=null;
181                                                        continue Z;
182                                                case OPPOSITE:
183                                                case OPPOSITE_LESS_RESTRICTIVE:
184                                                        return False.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                        And<T, C> ret = new And<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                return this;
224        }
225 
226        public boolean isContextDependent() {
227                for (Predicate<T, C> part: getParts()) {
228                        if (part.isContextDependent()) {
229                                return true;
230                        }
231                }
232                return false;
233        }
234 
235        @Override
236        public String toString() {
237                return getClass().getName()+getParts();
238        }
239        
240        @Override
241        public double getCost() {
242                if (cost==0 && costUnit==null) {
243                        double ret = 0;
244                        for (Predicate<T,C> part: parts) {
245                                ret+=part.getCost();
246                        }
247                        return ret;
248                }
249                return super.getCost();
250        }
251 
252        @Override
253        public Extractor<T, Boolean, C> map(int[] map) {
254                And<T,C> ret = new And<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                And<T,C> ret = (And<T, C>) super.clone();
265                ret.parts = new ArrayList<Predicate<T,C>>(parts); 
266                return ret;
267        }
268 
269        @Override
270        public And<T, C> add(Predicate<T, C> part) {
271                And<T, C> ret = new And<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