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