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}