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 010 * trunk/opends/resource/legal-notices/OpenDS.LICENSE 011 * or https://OpenDS.dev.java.net/OpenDS.LICENSE. 012 * See the License for the specific language governing permissions 013 * and limitations under the License. 014 * 015 * When distributing Covered Code, include this CDDL HEADER in each 016 * file and include the License file at 017 * trunk/opends/resource/legal-notices/OpenDS.LICENSE. If applicable, 018 * add the following below this CDDL HEADER, with the fields enclosed 019 * by brackets "[]" replaced with your own identifying information: 020 * Portions Copyright [yyyy] [name of copyright owner] 021 * 022 * CDDL HEADER END 023 * 024 * 025 * Copyright 2008 Sun Microsystems, Inc. 026 */ 027 package org.opends.server.core; 028 029 030 import java.util.LinkedHashSet; 031 import java.util.List; 032 import org.opends.server.controls.MatchedValuesControl; 033 import org.opends.server.types.ByteString; 034 import org.opends.server.types.Control; 035 import org.opends.server.types.DN; 036 import org.opends.server.types.DereferencePolicy; 037 import org.opends.server.types.DirectoryException; 038 import org.opends.server.types.Entry; 039 import org.opends.server.types.RawFilter; 040 import org.opends.server.types.SearchFilter; 041 import org.opends.server.types.SearchResultEntry; 042 import org.opends.server.types.SearchResultReference; 043 import org.opends.server.types.SearchScope; 044 045 046 /** 047 * This abstract class wraps/decorates a given search operation. 048 * This class will be extended by sub-classes to enhance the 049 * functionality of the SearchOperationBasis. 050 */ 051 public abstract class SearchOperationWrapper extends OperationWrapper 052 implements SearchOperation 053 { 054 // The wrapped operation. 055 private SearchOperation search; 056 057 /** 058 * Creates a new search operation based on the provided search operation. 059 * 060 * @param search The search operation to wrap 061 */ 062 protected SearchOperationWrapper(SearchOperation search) 063 { 064 super(search); 065 this.search = search; 066 } 067 068 /** 069 * {@inheritDoc} 070 */ 071 public boolean returnEntry(Entry entry, List<Control> controls) 072 { 073 boolean result; 074 075 result = this.search.returnEntry(entry, controls); 076 077 return result; 078 } 079 080 /** 081 * {@inheritDoc} 082 */ 083 public boolean returnReference(DN dn, SearchResultReference reference) 084 { 085 boolean result; 086 087 result = this.search.returnReference(dn, reference); 088 089 return result; 090 } 091 092 /** 093 * {@inheritDoc} 094 */ 095 public String toString() 096 { 097 return search.toString(); 098 } 099 100 /** 101 * {@inheritDoc} 102 */ 103 public LinkedHashSet<String> getAttributes() 104 { 105 return search.getAttributes(); 106 } 107 108 /** 109 * {@inheritDoc} 110 */ 111 public DN getBaseDN() 112 { 113 return search.getBaseDN(); 114 } 115 116 /** 117 * {@inheritDoc} 118 */ 119 public DereferencePolicy getDerefPolicy() 120 { 121 return search.getDerefPolicy(); 122 } 123 124 /** 125 * {@inheritDoc} 126 */ 127 public int getEntriesSent() 128 { 129 return search.getEntriesSent(); 130 } 131 132 /** 133 * {@inheritDoc} 134 */ 135 public SearchFilter getFilter() 136 { 137 return search.getFilter(); 138 } 139 140 /** 141 * {@inheritDoc} 142 */ 143 public ByteString getRawBaseDN() 144 { 145 return search.getRawBaseDN(); 146 } 147 148 /** 149 * {@inheritDoc} 150 */ 151 public RawFilter getRawFilter() 152 { 153 return search.getRawFilter(); 154 } 155 156 /** 157 * {@inheritDoc} 158 */ 159 public int getReferencesSent() 160 { 161 return search.getReferencesSent(); 162 } 163 164 /** 165 * {@inheritDoc} 166 */ 167 public SearchScope getScope() 168 { 169 return search.getScope(); 170 } 171 172 /** 173 * {@inheritDoc} 174 */ 175 public int getSizeLimit() 176 { 177 return search.getSizeLimit(); 178 } 179 180 /** 181 * {@inheritDoc} 182 */ 183 public int getTimeLimit() 184 { 185 return search.getTimeLimit(); 186 } 187 188 /** 189 * {@inheritDoc} 190 */ 191 public boolean getTypesOnly() 192 { 193 return search.getTypesOnly(); 194 } 195 196 /** 197 * {@inheritDoc} 198 */ 199 public void sendSearchResultDone() 200 { 201 search.sendSearchResultDone(); 202 } 203 204 /** 205 * {@inheritDoc} 206 */ 207 public void setAttributes(LinkedHashSet<String> attributes) 208 { 209 search.setAttributes(attributes); 210 } 211 212 /** 213 * {@inheritDoc} 214 */ 215 public void setBaseDN(DN baseDN) 216 { 217 search.setBaseDN(baseDN); 218 } 219 220 /** 221 * {@inheritDoc} 222 */ 223 public void setDerefPolicy(DereferencePolicy derefPolicy) 224 { 225 search.setDerefPolicy(derefPolicy); 226 } 227 228 /** 229 * {@inheritDoc} 230 */ 231 public void setRawBaseDN(ByteString rawBaseDN) 232 { 233 search.setRawBaseDN(rawBaseDN); 234 } 235 236 /** 237 * {@inheritDoc} 238 */ 239 public void setRawFilter(RawFilter rawFilter) 240 { 241 search.setRawFilter(rawFilter); 242 } 243 244 /** 245 * {@inheritDoc} 246 */ 247 public void setScope(SearchScope scope) 248 { 249 search.setScope(scope); 250 } 251 252 /** 253 * {@inheritDoc} 254 */ 255 public void setSizeLimit(int sizeLimit) 256 { 257 search.setSizeLimit(sizeLimit); 258 } 259 260 /** 261 * {@inheritDoc} 262 */ 263 public void setTimeLimit(int timeLimit) 264 { 265 search.setTimeLimit(timeLimit); 266 } 267 268 /** 269 * {@inheritDoc} 270 */ 271 public void setTypesOnly(boolean typesOnly) 272 { 273 search.setTypesOnly(typesOnly); 274 } 275 276 /** 277 * {@inheritDoc} 278 */ 279 public void setTimeLimitExpiration(Long timeLimitExpiration) 280 { 281 search.setTimeLimitExpiration(timeLimitExpiration); 282 } 283 284 /** 285 * {@inheritDoc} 286 */ 287 public boolean isReturnLDAPSubentries() 288 { 289 return search.isReturnLDAPSubentries(); 290 } 291 292 /** 293 * {@inheritDoc} 294 */ 295 public void setReturnLDAPSubentries(boolean returnLDAPSubentries) 296 { 297 search.setReturnLDAPSubentries(returnLDAPSubentries); 298 } 299 300 /** 301 * {@inheritDoc} 302 */ 303 public MatchedValuesControl getMatchedValuesControl() 304 { 305 return search.getMatchedValuesControl(); 306 } 307 308 /** 309 * {@inheritDoc} 310 */ 311 public void setMatchedValuesControl(MatchedValuesControl controls) 312 { 313 search.setMatchedValuesControl(controls); 314 } 315 316 /** 317 * {@inheritDoc} 318 */ 319 public boolean isIncludeUsableControl() 320 { 321 return search.isIncludeUsableControl(); 322 } 323 324 /** 325 * {@inheritDoc} 326 */ 327 public void setIncludeUsableControl(boolean includeUsableControl) 328 { 329 search.setIncludeUsableControl(includeUsableControl); 330 } 331 332 /** 333 * {@inheritDoc} 334 */ 335 public void setPersistentSearch(PersistentSearch psearch) 336 { 337 search.setPersistentSearch(psearch); 338 } 339 340 /** 341 * {@inheritDoc} 342 */ 343 public PersistentSearch getPersistentSearch() 344 { 345 return search.getPersistentSearch(); 346 } 347 348 /** 349 * {@inheritDoc} 350 */ 351 public Long getTimeLimitExpiration() 352 { 353 return search.getTimeLimitExpiration(); 354 } 355 356 /** 357 * {@inheritDoc} 358 */ 359 public boolean isClientAcceptsReferrals() 360 { 361 return search.isClientAcceptsReferrals(); 362 } 363 364 /** 365 * {@inheritDoc} 366 */ 367 public void setClientAcceptsReferrals(boolean clientAcceptReferrals) 368 { 369 search.setClientAcceptsReferrals(clientAcceptReferrals); 370 } 371 372 /** 373 * {@inheritDoc} 374 */ 375 public void incrementEntriesSent() 376 { 377 search.incrementEntriesSent(); 378 } 379 380 /** 381 * {@inheritDoc} 382 */ 383 public void incrementReferencesSent() 384 { 385 search.incrementReferencesSent(); 386 } 387 388 /** 389 * {@inheritDoc} 390 */ 391 public boolean isSendResponse() 392 { 393 return search.isSendResponse(); 394 } 395 396 /** 397 * {@inheritDoc} 398 */ 399 public void setSendResponse(boolean sendResponse) 400 { 401 search.setSendResponse(sendResponse); 402 } 403 404 /** 405 * {@inheritDoc} 406 */ 407 public boolean isRealAttributesOnly(){ 408 return search.isRealAttributesOnly(); 409 } 410 411 /** 412 * {@inheritDoc} 413 */ 414 public void setRealAttributesOnly(boolean realAttributesOnly){ 415 search.setRealAttributesOnly(realAttributesOnly); 416 } 417 418 /** 419 * {@inheritDoc} 420 */ 421 public boolean isVirtualAttributesOnly(){ 422 return search.isVirtualAttributesOnly(); 423 } 424 425 /** 426 * {@inheritDoc} 427 */ 428 public void setVirtualAttributesOnly(boolean virtualAttributesOnly){ 429 search.setVirtualAttributesOnly(virtualAttributesOnly); 430 } 431 432 /** 433 * {@inheritDoc} 434 * @throws DirectoryException 435 */ 436 public void sendSearchEntry(SearchResultEntry entry) 437 throws DirectoryException 438 { 439 search.sendSearchEntry(entry); 440 } 441 442 /** 443 * {@inheritDoc} 444 * @throws DirectoryException 445 */ 446 public boolean sendSearchReference(SearchResultReference reference) 447 throws DirectoryException 448 { 449 return search.sendSearchReference(reference); 450 } 451 452 /** 453 * {@inheritDoc} 454 */ 455 public DN getProxiedAuthorizationDN() 456 { 457 return search.getProxiedAuthorizationDN(); 458 } 459 460 /** 461 * {@inheritDoc} 462 */ 463 public void setProxiedAuthorizationDN(DN proxiedAuthorizationDN){ 464 search.setProxiedAuthorizationDN(proxiedAuthorizationDN); 465 } 466 467 }