001 /*
002 * Copyright 2009-2013 UnboundID Corp.
003 * All Rights Reserved.
004 */
005 /*
006 * Copyright (C) 2009-2013 UnboundID Corp.
007 *
008 * This program is free software; you can redistribute it and/or modify
009 * it under the terms of the GNU General Public License (GPLv2 only)
010 * or the terms of the GNU Lesser General Public License (LGPLv2.1 only)
011 * as published by the Free Software Foundation.
012 *
013 * This program is distributed in the hope that it will be useful,
014 * but WITHOUT ANY WARRANTY; without even the implied warranty of
015 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
016 * GNU General Public License for more details.
017 *
018 * You should have received a copy of the GNU General Public License
019 * along with this program; if not, see <http://www.gnu.org/licenses>.
020 */
021 package com.unboundid.ldap.sdk.migrate.ldapjdk;
022
023
024
025 import com.unboundid.util.Mutable;
026 import com.unboundid.util.NotExtensible;
027 import com.unboundid.util.ThreadSafety;
028 import com.unboundid.util.ThreadSafetyLevel;
029
030
031
032 /**
033 * This class provides a data structure which may be used to define a set of
034 * constraints that may be used when processing search operations.
035 * <BR><BR>
036 * This class is primarily intended to be used in the process of updating
037 * applications which use the Netscape Directory SDK for Java to switch to or
038 * coexist with the UnboundID LDAP SDK for Java. For applications not written
039 * using the Netscape Directory SDK for Java, the
040 * {@link com.unboundid.ldap.sdk.LDAPConnectionOptions} class should be used
041 * instead.
042 */
043 @NotExtensible()
044 @Mutable()
045 @ThreadSafety(level=ThreadSafetyLevel.NOT_THREADSAFE)
046 public class LDAPSearchConstraints
047 extends LDAPConstraints
048 {
049 /**
050 * The serial version UID for this serializable class.
051 */
052 private static final long serialVersionUID = -487551577157782460L;
053
054
055
056 // The result batch size.
057 private int batchSize;
058
059 // The alias dereferencing policy.
060 private int derefPolicy;
061
062 // The maximum number of results to return for a search.
063 private int sizeLimit;
064
065 // The maximum length of time in seconds the server should spend processing a
066 // search.
067 private int timeLimit;
068
069
070
071 /**
072 * Creates a new set of search constraints with the default settings.
073 */
074 public LDAPSearchConstraints()
075 {
076 super();
077
078 batchSize = 1;
079 derefPolicy = LDAPConnection.DEREF_NEVER;
080 sizeLimit = 1000;
081 timeLimit = 0;
082 }
083
084
085
086 /**
087 * Creates a new set of search constraints with the specified information.
088 *
089 * @param msLimit The maximum length of time in milliseconds to spend
090 * waiting for the response.
091 * @param dereference The policy to use when dereferencing aliases.
092 * @param maxResults The maximum number of entries to return from the
093 * server.
094 * @param doReferrals Indicates whether to follow referrals.
095 * @param batchSize The batch size to use when retrieving results.
096 * @param rebindProc The object to use to obtain information for
097 * authenticating the connection for use when following
098 * referrals.
099 * @param hopLimit The maximum number of hops to take when following
100 * referrals.
101 */
102 public LDAPSearchConstraints(final int msLimit, final int dereference,
103 final int maxResults, final boolean doReferrals,
104 final int batchSize, final LDAPRebind rebindProc,
105 final int hopLimit)
106 {
107 this();
108
109 derefPolicy = dereference;
110 sizeLimit = maxResults;
111 this.batchSize = batchSize;
112
113 setTimeLimit(msLimit);
114 setReferrals(doReferrals);
115 setRebindProc(rebindProc);
116 setHopLimit(hopLimit);
117 }
118
119
120
121 /**
122 * Creates a new set of search constraints with the specified information.
123 *
124 * @param msLimit The maximum length of time in milliseconds to spend
125 * waiting for the response.
126 * @param timeLimit The maximum length of time in seconds the server
127 * should spend processing the request.
128 * @param dereference The policy to use when dereferencing aliases.
129 * @param maxResults The maximum number of entries to return from the
130 * server.
131 * @param doReferrals Indicates whether to follow referrals.
132 * @param batchSize The batch size to use when retrieving results.
133 * @param rebindProc The object to use to obtain information for
134 * authenticating the connection for use when following
135 * referrals.
136 * @param hopLimit The maximum number of hops to take when following
137 * referrals.
138 */
139 public LDAPSearchConstraints(final int msLimit, final int timeLimit,
140 final int dereference,
141 final int maxResults, final boolean doReferrals,
142 final int batchSize, final LDAPRebind rebindProc,
143 final int hopLimit)
144 {
145 this();
146
147 derefPolicy = dereference;
148 sizeLimit = maxResults;
149 this.timeLimit = timeLimit;
150 this.batchSize = batchSize;
151
152 setTimeLimit(msLimit);
153 setReferrals(doReferrals);
154 setRebindProc(rebindProc);
155 setHopLimit(hopLimit);
156 }
157
158
159
160 /**
161 * Creates a new set of search constraints with the specified information.
162 *
163 * @param msLimit The maximum length of time in milliseconds to spend
164 * waiting for the response.
165 * @param timeLimit The maximum length of time in seconds the server
166 * should spend processing the request.
167 * @param dereference The policy to use when dereferencing aliases.
168 * @param maxResults The maximum number of entries to return from the
169 * server.
170 * @param doReferrals Indicates whether to follow referrals.
171 * @param batchSize The batch size to use when retrieving results.
172 * @param bindProc The object to use to obtain authenticating the
173 * connection for use when following referrals.
174 * @param hopLimit The maximum number of hops to take when following
175 * referrals.
176 */
177 public LDAPSearchConstraints(final int msLimit, final int timeLimit,
178 final int dereference,
179 final int maxResults, final boolean doReferrals,
180 final int batchSize, final LDAPBind bindProc,
181 final int hopLimit)
182 {
183 this();
184
185 derefPolicy = dereference;
186 sizeLimit = maxResults;
187 this.timeLimit = timeLimit;
188 this.batchSize = batchSize;
189
190 setTimeLimit(msLimit);
191 setReferrals(doReferrals);
192 setBindProc(bindProc);
193 setHopLimit(hopLimit);
194 }
195
196
197
198 /**
199 * Retrieves the suggested batch size to use when retrieving results.
200 *
201 * @return The suggested batch size to use when retrieving results.
202 */
203 public int getBatchSize()
204 {
205 return batchSize;
206 }
207
208
209
210 /**
211 * Specifies the suggested batch size to use when retrieving results.
212 *
213 * @param batchSize The suggested batch size to use when retrieving results.
214 */
215 public void setBatchSize(final int batchSize)
216 {
217 if (batchSize < 1)
218 {
219 this.batchSize = 1;
220 }
221 else
222 {
223 this.batchSize = batchSize;
224 }
225 }
226
227
228
229 /**
230 * Retrieves the alias dereferencing policy that should be used.
231 *
232 * @return The alias dereferencing policy that should be used.
233 */
234 public int getDereference()
235 {
236 return derefPolicy;
237 }
238
239
240
241 /**
242 * Specifies the alias dereferencing policy that should be used.
243 *
244 * @param dereference The alias dereferencing policy that should be used.
245 */
246 public void setDereference(final int dereference)
247 {
248 derefPolicy = dereference;
249 }
250
251
252
253 /**
254 * Retrieves the maximum number of entries that should be returned for a
255 * search.
256 *
257 * @return The maximum number of entries that should be returned for a
258 * search.
259 */
260 public int getMaxResults()
261 {
262 return sizeLimit;
263 }
264
265
266
267 /**
268 * Specifies the maximum number of entries that should be returned for a
269 * search.
270 *
271 * @param maxResults The maximum number of entries that should be returned
272 * for a search.
273 */
274 public void setMaxResults(final int maxResults)
275 {
276 if (maxResults < 0)
277 {
278 sizeLimit = 0;
279 }
280 else
281 {
282 sizeLimit = maxResults;
283 }
284 }
285
286
287
288 /**
289 * Retrieves the maximum length of time in seconds that the server should
290 * spend processing a search.
291 *
292 * @return The maximum length of time in seconds that the server should spend
293 * processing a search.
294 */
295 public int getServerTimeLimit()
296 {
297 return timeLimit;
298 }
299
300
301
302 /**
303 * Specifies the maximum length of time in seconds that the server should
304 * spend processing a search.
305 *
306 * @param limit The maximum length of time in seconds that the server should
307 * spend processing a search.
308 */
309 public void setServerTimeLimit(final int limit)
310 {
311 if (limit < 0)
312 {
313 timeLimit = 0;
314 }
315 else
316 {
317 timeLimit = limit;
318 }
319 }
320
321
322
323 /**
324 * Creates a duplicate of this search constraints object.
325 *
326 * @return A duplicate of this search constraints object.
327 */
328 @Override()
329 public LDAPSearchConstraints duplicate()
330 {
331 final LDAPSearchConstraints c = new LDAPSearchConstraints();
332
333 c.batchSize = batchSize;
334 c.derefPolicy = derefPolicy;
335 c.sizeLimit = sizeLimit;
336 c.timeLimit = timeLimit;
337
338 c.setBindProc(getBindProc());
339 c.setClientControls(getClientControls());
340 c.setReferrals(getReferrals());
341 c.setHopLimit(getHopLimit());
342 c.setRebindProc(getRebindProc());
343 c.setServerControls(getServerControls());
344 c.setTimeLimit(getTimeLimit());
345
346 return c;
347 }
348
349
350
351 /**
352 * Retrieves a string representation of this search constraints object.
353 *
354 * @return A string representation of this search constraints object.
355 */
356 @Override()
357 public String toString()
358 {
359 final StringBuilder buffer = new StringBuilder();
360
361 buffer.append("LDAPSearchConstraints(constraints=");
362 buffer.append(super.toString());
363 buffer.append(", batchSize=");
364 buffer.append(batchSize);
365 buffer.append(", derefPolicy=");
366 buffer.append(derefPolicy);
367 buffer.append(", maxResults=");
368 buffer.append(sizeLimit);
369 buffer.append(", serverTimeLimit=");
370 buffer.append(timeLimit);
371 buffer.append(')');
372
373 return buffer.toString();
374 }
375 }