1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17 package org.apache.ldap.server.db;
18
19
20 import javax.naming.NamingEnumeration;
21 import javax.naming.NamingException;
22 import java.util.NoSuchElementException;
23
24
25 /***
26 * A simple NamingEnumeration over a TupleBrowser on a table that does not allow
27 * duplicates.
28 *
29 * <p> WARNING: The Tuple returned by this listing is always the same instance
30 * object returned every time. It is reused to for the sake of efficency rather
31 * than creating a new tuple for each hasMore() call.
32 * </p>
33 *
34 * @author <a href="mailto:dev@directory.apache.org">Apache Directory Project</a>
35 * @version $Rev: 159259 $
36 */
37 public class NoDupsEnumeration
38 implements NamingEnumeration
39 {
40 /*** Temporary Tuple used to return results */
41 private final Tuple returned = new Tuple();
42 /*** Temporary Tuple used to store prefetched values */
43 private final Tuple prefetched = new Tuple();
44 /*** The JDBM TupleBrowser this NamingEnumeration wraps */
45 private final TupleBrowser browser;
46 /*** The direction of this NamingEnumeration */
47 private final boolean doAscendingScan;
48 /*** Whether or not this NamingEnumeration can advance */
49 private boolean hasNext = true;
50
51
52
53
54
55
56
57 /***
58 * Creates a cursor over a TupleBrowser where duplicates are not expected.
59 *
60 * @param browser TODO
61 * @param doAscendingScan TODO
62 * @throws NamingException TODO
63 */
64 public NoDupsEnumeration( TupleBrowser browser, boolean doAscendingScan )
65 throws NamingException
66 {
67 this.browser = browser;
68 this.doAscendingScan = doAscendingScan;
69 prefetch();
70 }
71
72
73
74
75
76
77
78 /***
79 * Returns the same Tuple every time but with different key/value pairs.
80 *
81 * @see javax.naming.NamingEnumeration#next()
82 */
83 public Object next()
84 throws NamingException
85 {
86
87 returned.setKey( prefetched.getKey() );
88 returned.setValue( prefetched.getValue() );
89
90
91 prefetch();
92 return returned;
93 }
94
95
96 /***
97 * Returns the same Tuple every time but with different key/value pairs.
98 *
99 * @see java.util.Enumeration#nextElement()
100 */
101 public Object nextElement()
102 {
103 try
104 {
105 return next();
106 }
107 catch ( NamingException e )
108 {
109 throw new NoSuchElementException();
110 }
111 }
112
113
114 /***
115 * @see javax.naming.NamingEnumeration#hasMore()
116 */
117 public boolean hasMore()
118 {
119 return hasNext;
120 }
121
122
123 /***
124 * Calls hasMore.
125 *
126 * @see java.util.Enumeration#hasMoreElements()
127 */
128 public boolean hasMoreElements()
129 {
130 return hasNext;
131 }
132
133
134 /***
135 * Sets hasNext to false.
136 *
137 * @see javax.naming.NamingEnumeration#close()
138 */
139 public void close()
140 {
141 hasNext = false;
142 }
143
144
145
146
147
148
149
150 /***
151 * Gets the direction of this NamingEnumeration.
152 *
153 * @return true if this NamingEnumeration is ascending on keys, false
154 * otherwise.
155 */
156 boolean doAscendingScan()
157 {
158 return doAscendingScan;
159 }
160
161
162 /***
163 * Prefetches a value into prefetched over writing whatever values were
164 * contained in the Tuple.
165 *
166 * @throws NamingException if the TupleBrowser browser could not advance
167 */
168 private void prefetch() throws NamingException
169 {
170
171 boolean isSuccess = false;
172
173 if ( doAscendingScan )
174 {
175 isSuccess = browser.getNext( prefetched );
176 }
177 else
178 {
179 isSuccess = browser.getPrevious( prefetched );
180 }
181
182 hasNext = isSuccess;
183 }
184 }