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}