001/*
002 * The contents of this file are subject to the terms of the Common Development and
003 * Distribution License (the License). You may not use this file except in compliance with the
004 * License.
005 *
006 * You can obtain a copy of the License at legal/CDDLv1.0.txt. See the License for the
007 * specific language governing permission and limitations under the License.
008 *
009 * When distributing Covered Software, include this CDDL Header Notice in each file and include
010 * the License file at legal/CDDLv1.0.txt. If applicable, add the following below the CDDL
011 * Header, with the fields enclosed by brackets [] replaced by your own identifying
012 * information: "Portions Copyright [year] [name of copyright owner]".
013 *
014 * Copyright 2010 Sun Microsystems, Inc.
015 * Portions Copyright 2011-2016 ForgeRock AS.
016 */
017package org.forgerock.opendj.ldap;
018
019import java.util.Collection;
020
021import org.forgerock.opendj.ldap.requests.AbandonRequest;
022import org.forgerock.opendj.ldap.requests.AddRequest;
023import org.forgerock.opendj.ldap.requests.BindRequest;
024import org.forgerock.opendj.ldap.requests.CompareRequest;
025import org.forgerock.opendj.ldap.requests.DeleteRequest;
026import org.forgerock.opendj.ldap.requests.ExtendedRequest;
027import org.forgerock.opendj.ldap.requests.ModifyDNRequest;
028import org.forgerock.opendj.ldap.requests.ModifyRequest;
029import org.forgerock.opendj.ldap.requests.SearchRequest;
030import org.forgerock.opendj.ldap.requests.UnbindRequest;
031import org.forgerock.opendj.ldap.responses.BindResult;
032import org.forgerock.opendj.ldap.responses.CompareResult;
033import org.forgerock.opendj.ldap.responses.ExtendedResult;
034import org.forgerock.opendj.ldap.responses.GenericExtendedResult;
035import org.forgerock.opendj.ldap.responses.Result;
036import org.forgerock.opendj.ldap.responses.SearchResultEntry;
037import org.forgerock.opendj.ldap.responses.SearchResultReference;
038import org.forgerock.opendj.ldif.ChangeRecord;
039import org.forgerock.opendj.ldif.ConnectionEntryReader;
040
041import org.forgerock.util.Reject;
042
043/**
044 * An abstract base class from which connection wrappers may be easily
045 * implemented. The default implementation of each method is to delegate to the
046 * wrapped connection.
047 *
048 * @param <C>
049 *            The type of wrapped connection.
050 */
051public abstract class AbstractConnectionWrapper<C extends Connection> implements Connection {
052    /** The wrapped connection. */
053    protected final C connection;
054
055    /**
056     * Creates a new connection wrapper.
057     *
058     * @param connection
059     *            The connection to be wrapped.
060     */
061    protected AbstractConnectionWrapper(final C connection) {
062        Reject.ifNull(connection);
063        this.connection = connection;
064    }
065
066    /**
067     * {@inheritDoc}
068     * <p>
069     * The default implementation is to delegate.
070     */
071    @Override
072    public LdapPromise<Void> abandonAsync(final AbandonRequest request) {
073        return connection.abandonAsync(request);
074    }
075
076    /**
077     * {@inheritDoc}
078     * <p>
079     * The default implementation is to delegate.
080     */
081    @Override
082    public Result add(final AddRequest request) throws LdapException {
083        return connection.add(request);
084    }
085
086    /**
087     * {@inheritDoc}
088     * <p>
089     * The default implementation is to delegate.
090     */
091    @Override
092    public Result add(final Entry entry) throws LdapException {
093        return connection.add(entry);
094    }
095
096    /**
097     * {@inheritDoc}
098     * <p>
099     * The default implementation is to delegate.
100     */
101    @Override
102    public Result add(final String... ldifLines) throws LdapException {
103        return connection.add(ldifLines);
104    }
105
106    /**
107     * {@inheritDoc}
108     * <p>
109     * The default implementation is to delegate.
110     */
111    @Override
112    public LdapPromise<Result> addAsync(final AddRequest request) {
113        return connection.addAsync(request);
114    }
115
116    /**
117     * {@inheritDoc}
118     * <p>
119     * The default implementation is to delegate.
120     */
121    @Override
122    public LdapPromise<Result> addAsync(final AddRequest request,
123            final IntermediateResponseHandler intermediateResponseHandler) {
124        return connection.addAsync(request, intermediateResponseHandler);
125    }
126
127    /**
128     * {@inheritDoc}
129     * <p>
130     * The default implementation is to delegate.
131     */
132    @Override
133    public void addConnectionEventListener(final ConnectionEventListener listener) {
134        connection.addConnectionEventListener(listener);
135    }
136
137    /**
138     * {@inheritDoc}
139     * <p>
140     * The default implementation is to delegate.
141     */
142    @Override
143    public Result applyChange(final ChangeRecord request) throws LdapException {
144        return connection.applyChange(request);
145    }
146
147    /**
148     * {@inheritDoc}
149     * <p>
150     * The default implementation is to delegate.
151     */
152    @Override
153    public LdapPromise<Result> applyChangeAsync(ChangeRecord request) {
154        return connection.applyChangeAsync(request);
155    }
156
157    /**
158     * {@inheritDoc}
159     * <p>
160     * The default implementation is to delegate.
161     */
162    @Override
163    public LdapPromise<Result> applyChangeAsync(ChangeRecord request,
164            IntermediateResponseHandler intermediateResponseHandler) {
165        return connection.applyChangeAsync(request, intermediateResponseHandler);
166    }
167
168    /**
169     * {@inheritDoc}
170     * <p>
171     * The default implementation is to delegate.
172     */
173    @Override
174    public BindResult bind(final BindRequest request) throws LdapException {
175        return connection.bind(request);
176    }
177
178    /**
179     * {@inheritDoc}
180     * <p>
181     * The default implementation is to delegate.
182     */
183    @Override
184    public BindResult bind(final String name, final char[] password) throws LdapException {
185        return connection.bind(name, password);
186    }
187
188    /**
189     * {@inheritDoc}
190     * <p>
191     * The default implementation is to delegate.
192     */
193    @Override
194    public LdapPromise<BindResult> bindAsync(final BindRequest request) {
195        return connection.bindAsync(request);
196    }
197
198    /**
199     * {@inheritDoc}
200     * <p>
201     * The default implementation is to delegate.
202     */
203    @Override
204    public LdapPromise<BindResult> bindAsync(BindRequest request,
205            IntermediateResponseHandler intermediateResponseHandler) {
206        return connection.bindAsync(request, intermediateResponseHandler);
207    }
208
209    /**
210     * {@inheritDoc}
211     * <p>
212     * The default implementation is to delegate.
213     */
214    @Override
215    public void close() {
216        connection.close();
217    }
218
219    /**
220     * {@inheritDoc}
221     * <p>
222     * The default implementation is to delegate.
223     */
224    @Override
225    public void close(final UnbindRequest request, final String reason) {
226        connection.close(request, reason);
227    }
228
229    /**
230     * {@inheritDoc}
231     * <p>
232     * The default implementation is to delegate.
233     */
234    @Override
235    public CompareResult compare(final CompareRequest request) throws LdapException {
236        return connection.compare(request);
237    }
238
239    /**
240     * {@inheritDoc}
241     * <p>
242     * The default implementation is to delegate.
243     */
244    @Override
245    public CompareResult compare(final String name, final String attributeDescription, final String assertionValue)
246            throws LdapException {
247        return connection.compare(name, attributeDescription, assertionValue);
248    }
249
250    /**
251     * {@inheritDoc}
252     * <p>
253     * The default implementation is to delegate.
254     */
255    @Override
256    public LdapPromise<CompareResult> compareAsync(final CompareRequest request) {
257        return connection.compareAsync(request);
258    }
259
260    /**
261     * {@inheritDoc}
262     * <p>
263     * The default implementation is to delegate.
264     */
265    @Override
266    public LdapPromise<CompareResult> compareAsync(CompareRequest request,
267            IntermediateResponseHandler intermediateResponseHandler) {
268        return connection.compareAsync(request, intermediateResponseHandler);
269    }
270
271    /**
272     * {@inheritDoc}
273     * <p>
274     * The default implementation is to delegate.
275     */
276    @Override
277    public Result delete(final DeleteRequest request) throws LdapException {
278        return connection.delete(request);
279    }
280
281    /**
282     * {@inheritDoc}
283     * <p>
284     * The default implementation is to delegate.
285     */
286    @Override
287    public Result delete(final String name) throws LdapException {
288        return connection.delete(name);
289    }
290
291    /**
292     * {@inheritDoc}
293     * <p>
294     * The default implementation is to delegate.
295     */
296    @Override
297    public LdapPromise<Result> deleteAsync(final DeleteRequest request) {
298        return connection.deleteAsync(request);
299    }
300
301    /**
302     * {@inheritDoc}
303     * <p>
304     * The default implementation is to delegate.
305     */
306    @Override
307    public LdapPromise<Result> deleteAsync(DeleteRequest request,
308            IntermediateResponseHandler intermediateResponseHandler) {
309        return connection.deleteAsync(request, intermediateResponseHandler);
310    }
311
312    /**
313     * {@inheritDoc}
314     * <p>
315     * The default implementation is to delegate.
316     */
317    @Override
318    public Result deleteSubtree(final String name) throws LdapException {
319        return connection.deleteSubtree(name);
320    }
321
322    /**
323     * {@inheritDoc}
324     * <p>
325     * The default implementation is to delegate.
326     */
327    @Override
328    public <R extends ExtendedResult> R extendedRequest(final ExtendedRequest<R> request) throws LdapException {
329        return connection.extendedRequest(request);
330    }
331
332    /**
333     * {@inheritDoc}
334     * <p>
335     * The default implementation is to delegate.
336     */
337    @Override
338    public <R extends ExtendedResult> R extendedRequest(final ExtendedRequest<R> request,
339            final IntermediateResponseHandler handler) throws LdapException {
340        return connection.extendedRequest(request, handler);
341    }
342
343    /**
344     * {@inheritDoc}
345     * <p>
346     * The default implementation is to delegate.
347     */
348    @Override
349    public GenericExtendedResult extendedRequest(final String requestName, final ByteString requestValue)
350            throws LdapException {
351        return connection.extendedRequest(requestName, requestValue);
352    }
353
354    /**
355     * {@inheritDoc}
356     * <p>
357     * The default implementation is to delegate.
358     */
359    @Override
360    public <R extends ExtendedResult> LdapPromise<R> extendedRequestAsync(final ExtendedRequest<R> request) {
361        return connection.extendedRequestAsync(request);
362    }
363
364    /**
365     * {@inheritDoc}
366     * <p>
367     * The default implementation is to delegate.
368     */
369    @Override
370    public <R extends ExtendedResult> LdapPromise<R> extendedRequestAsync(ExtendedRequest<R> request,
371            IntermediateResponseHandler intermediateResponseHandler) {
372        return connection.extendedRequestAsync(request, intermediateResponseHandler);
373    }
374
375    /**
376     * {@inheritDoc}
377     * <p>
378     * The default implementation is to delegate.
379     */
380    @Override
381    public boolean isClosed() {
382        return connection.isClosed();
383    }
384
385    /**
386     * {@inheritDoc}
387     * <p>
388     * The default implementation is to delegate.
389     */
390    @Override
391    public boolean isValid() {
392        return connection.isValid();
393    }
394
395    /**
396     * {@inheritDoc}
397     * <p>
398     * The default implementation is to delegate.
399     */
400    @Override
401    public Result modify(final ModifyRequest request) throws LdapException {
402        return connection.modify(request);
403    }
404
405    /**
406     * {@inheritDoc}
407     * <p>
408     * The default implementation is to delegate.
409     */
410    @Override
411    public Result modify(final String... ldifLines) throws LdapException {
412        return connection.modify(ldifLines);
413    }
414
415    /**
416     * {@inheritDoc}
417     * <p>
418     * The default implementation is to delegate.
419     */
420    @Override
421    public LdapPromise<Result> modifyAsync(final ModifyRequest request) {
422        return connection.modifyAsync(request);
423    }
424
425    /**
426     * {@inheritDoc}
427     * <p>
428     * The default implementation is to delegate.
429     */
430    @Override
431    public LdapPromise<Result> modifyAsync(ModifyRequest request,
432            IntermediateResponseHandler intermediateResponseHandler) {
433        return connection.modifyAsync(request, intermediateResponseHandler);
434    }
435
436    /**
437     * {@inheritDoc}
438     * <p>
439     * The default implementation is to delegate.
440     */
441    @Override
442    public Result modifyDN(final ModifyDNRequest request) throws LdapException {
443        return connection.modifyDN(request);
444    }
445
446    /**
447     * {@inheritDoc}
448     * <p>
449     * The default implementation is to delegate.
450     */
451    @Override
452    public Result modifyDN(final String name, final String newRDN) throws LdapException {
453        return connection.modifyDN(name, newRDN);
454    }
455
456    /**
457     * {@inheritDoc}
458     * <p>
459     * The default implementation is to delegate.
460     */
461    @Override
462    public LdapPromise<Result> modifyDNAsync(final ModifyDNRequest request) {
463        return connection.modifyDNAsync(request);
464    }
465
466    /**
467     * {@inheritDoc}
468     * <p>
469     * The default implementation is to delegate.
470     */
471    @Override
472    public LdapPromise<Result> modifyDNAsync(ModifyDNRequest request,
473            IntermediateResponseHandler intermediateResponseHandler) {
474        return modifyDNAsync(request, intermediateResponseHandler);
475    }
476
477    /**
478     * {@inheritDoc}
479     * <p>
480     * The default implementation is to delegate.
481     */
482    @Override
483    public SearchResultEntry readEntry(final DN name, final String... attributeDescriptions) throws LdapException {
484        return connection.readEntry(name, attributeDescriptions);
485    }
486
487    /**
488     * {@inheritDoc}
489     * <p>
490     * The default implementation is to delegate.
491     */
492    @Override
493    public SearchResultEntry readEntry(final String name, final String... attributeDescriptions) throws LdapException {
494        return connection.readEntry(name, attributeDescriptions);
495    }
496
497    /**
498     * {@inheritDoc}
499     * <p>
500     * The default implementation is to delegate.
501     */
502    @Override
503    public LdapPromise<SearchResultEntry> readEntryAsync(final DN name,
504            final Collection<String> attributeDescriptions) {
505        return connection.readEntryAsync(name, attributeDescriptions);
506    }
507
508    /**
509     * {@inheritDoc}
510     * <p>
511     * The default implementation is to delegate.
512     */
513    @Override
514    public void removeConnectionEventListener(final ConnectionEventListener listener) {
515        connection.removeConnectionEventListener(listener);
516    }
517
518    /**
519     * {@inheritDoc}
520     * <p>
521     * The default implementation is to delegate.
522     */
523    @Override
524    public ConnectionEntryReader search(final SearchRequest request) {
525        return connection.search(request);
526    }
527
528    /**
529     * {@inheritDoc}
530     * <p>
531     * The default implementation is to delegate.
532     */
533    @Override
534    public Result search(final SearchRequest request,
535            final Collection<? super SearchResultEntry> entries) throws LdapException {
536        return connection.search(request, entries);
537    }
538
539    /**
540     * {@inheritDoc}
541     * <p>
542     * The default implementation is to delegate.
543     */
544    @Override
545    public Result search(final SearchRequest request,
546            final Collection<? super SearchResultEntry> entries,
547            final Collection<? super SearchResultReference> references) throws LdapException {
548        return connection.search(request, entries, references);
549    }
550
551    /**
552     * {@inheritDoc}
553     * <p>
554     * The default implementation is to delegate.
555     */
556    @Override
557    public Result search(final SearchRequest request, final SearchResultHandler handler) throws LdapException {
558        return connection.search(request, handler);
559    }
560
561    /**
562     * {@inheritDoc}
563     * <p>
564     * The default implementation is to delegate.
565     */
566    @Override
567    public ConnectionEntryReader search(final String baseObject, final SearchScope scope,
568            final String filter, final String... attributeDescriptions) {
569        return connection.search(baseObject, scope, filter, attributeDescriptions);
570    }
571
572    /**
573     * {@inheritDoc}
574     * <p>
575     * The default implementation is to delegate.
576     */
577    @Override
578    public LdapPromise<Result> searchAsync(final SearchRequest request,
579            final SearchResultHandler resultHandler) {
580        return connection.searchAsync(request, resultHandler);
581    }
582
583    /**
584     * {@inheritDoc}
585     * <p>
586     * The default implementation is to delegate.
587     */
588    @Override
589    public LdapPromise<Result> searchAsync(SearchRequest request,
590            IntermediateResponseHandler intermediateResponseHandler, SearchResultHandler entryHandler) {
591        return connection.searchAsync(request, intermediateResponseHandler, entryHandler);
592    }
593
594    /**
595     * {@inheritDoc}
596     * <p>
597     * The default implementation is to delegate.
598     */
599    @Override
600    public SearchResultEntry searchSingleEntry(final SearchRequest request) throws LdapException {
601        return connection.searchSingleEntry(request);
602    }
603
604    /**
605     * {@inheritDoc}
606     * <p>
607     * The default implementation is to delegate.
608     */
609    @Override
610    public SearchResultEntry searchSingleEntry(final String baseObject, final SearchScope scope, final String filter,
611            final String... attributeDescriptions) throws LdapException {
612        return connection.searchSingleEntry(baseObject, scope, filter, attributeDescriptions);
613    }
614
615    /**
616     * {@inheritDoc}
617     * <p>
618     * The default implementation is to delegate.
619     */
620    @Override
621    public LdapPromise<SearchResultEntry> searchSingleEntryAsync(final SearchRequest request) {
622        return connection.searchSingleEntryAsync(request);
623    }
624
625    /**
626     * {@inheritDoc}
627     * <p>
628     * The default implementation is to delegate.
629     */
630    @Override
631    public String toString() {
632        return connection.toString();
633    }
634
635}