1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20 package org.apache.directory.server.xdbm.search.impl;
21
22
23 import org.apache.directory.shared.ldap.filter.LessEqNode;
24 import org.apache.directory.shared.ldap.schema.AttributeType;
25 import org.apache.directory.shared.ldap.schema.MatchingRule;
26 import org.apache.directory.shared.ldap.schema.Normalizer;
27 import org.apache.directory.shared.ldap.entry.Value;
28 import org.apache.directory.server.xdbm.IndexEntry;
29 import org.apache.directory.server.xdbm.Store;
30 import org.apache.directory.server.xdbm.Index;
31 import org.apache.directory.server.xdbm.search.Evaluator;
32 import org.apache.directory.server.schema.registries.Registries;
33 import org.apache.directory.server.core.entry.ServerEntry;
34 import org.apache.directory.server.core.entry.ServerAttribute;
35
36 import java.util.Iterator;
37 import java.util.Comparator;
38
39
40
41
42
43
44
45
46
47 public class LessEqEvaluator implements Evaluator<LessEqNode, ServerEntry>
48 {
49 private final LessEqNode node;
50 private final Store<ServerEntry> db;
51 private final Registries registries;
52 private final AttributeType type;
53 private final Normalizer normalizer;
54 private final Comparator comparator;
55 private final Index<Object,ServerEntry> idx;
56
57
58 public LessEqEvaluator( LessEqNode node, Store<ServerEntry> db, Registries registries )
59 throws Exception
60 {
61 this.db = db;
62 this.node = node;
63 this.registries = registries;
64 this.type = registries.getAttributeTypeRegistry().lookup( node.getAttribute() );
65
66 if ( db.hasUserIndexOn( node.getAttribute() ) )
67 {
68
69 idx = ( Index<Object,ServerEntry> ) db.getUserIndex( node.getAttribute() );
70 }
71 else
72 {
73 idx = null;
74 }
75
76
77
78
79
80
81
82 MatchingRule mr = type.getOrdering();
83
84 if ( mr == null )
85 {
86 mr = type.getEquality();
87 }
88
89 if ( mr == null )
90 {
91 throw new IllegalStateException(
92 "Could not find matchingRule to use for LessEqNode evaluation: " + node );
93 }
94
95 normalizer = mr.getNormalizer();
96 comparator = mr.getComparator();
97 }
98
99
100 public LessEqNode getExpression()
101 {
102 return node;
103 }
104
105
106 public AttributeType getAttributeType()
107 {
108 return type;
109 }
110
111
112 public Normalizer getNormalizer()
113 {
114 return normalizer;
115 }
116
117
118 public Comparator getComparator()
119 {
120 return comparator;
121 }
122
123
124 public boolean evaluate( Long id ) throws Exception
125 {
126 if ( idx != null )
127 {
128 return idx.reverseLessOrEq( id, node.getValue().get() );
129 }
130
131 return evaluate( db.lookup( id ) );
132 }
133
134
135 public boolean evaluate( IndexEntry<?,ServerEntry> indexEntry ) throws Exception
136 {
137 if ( idx != null )
138 {
139 return idx.reverseLessOrEq( indexEntry.getId(), node.getValue().get() );
140 }
141
142 ServerEntry entry = indexEntry.getObject();
143
144
145 if ( null == entry )
146 {
147 entry = db.lookup( indexEntry.getId() );
148 indexEntry.setObject( entry );
149 }
150
151 if ( null == entry )
152 {
153 return false;
154 }
155
156
157 ServerAttribute attr = ( ServerAttribute ) entry.get( type );
158
159
160
161 if ( attr != null && evaluate( ( IndexEntry<Object,ServerEntry> ) indexEntry, attr ) )
162 {
163 return true;
164 }
165
166
167
168
169 if ( registries.getAttributeTypeRegistry().hasDescendants( node.getAttribute() ) )
170 {
171
172
173
174 Iterator<AttributeType> descendants =
175 registries.getAttributeTypeRegistry().descendants( node.getAttribute() );
176
177 while ( descendants.hasNext() )
178 {
179 AttributeType descendant = descendants.next();
180
181 attr = ( ServerAttribute ) entry.get( descendant );
182
183
184 if ( attr != null && evaluate( ( IndexEntry<Object,ServerEntry> ) indexEntry, attr ) )
185 {
186 return true;
187 }
188 }
189 }
190
191
192 return false;
193 }
194
195
196 public boolean evaluate( ServerEntry entry ) throws Exception
197 {
198
199 ServerAttribute attr = ( ServerAttribute ) entry.get( type );
200
201
202 if ( attr != null && evaluate( null, attr ) )
203 {
204 return true;
205 }
206
207
208
209
210 if ( registries.getAttributeTypeRegistry().hasDescendants( node.getAttribute() ) )
211 {
212
213
214
215 Iterator<AttributeType> descendants =
216 registries.getAttributeTypeRegistry().descendants( node.getAttribute() );
217
218 while ( descendants.hasNext() )
219 {
220 AttributeType descendant = descendants.next();
221
222 attr = ( ServerAttribute ) entry.get( descendant );
223
224 if ( attr != null && evaluate( null, attr ) )
225 {
226 return true;
227 }
228 }
229 }
230
231
232 return false;
233 }
234
235
236
237
238 private boolean evaluate( IndexEntry<Object,ServerEntry> indexEntry, ServerAttribute attribute ) throws Exception
239 {
240
241
242
243
244
245
246 for ( Value value : attribute )
247 {
248 value.normalize( normalizer );
249
250
251 if ( comparator.compare( value.getNormalizedValue(), node.getValue().getNormalizedValue() ) <= 0 )
252 {
253 if ( indexEntry != null )
254 {
255 indexEntry.setValue( value.getNormalizedValue() );
256 }
257 return true;
258 }
259 }
260
261 return false;
262 }
263 }