001 /*
002 * Copyright 2011-2013 UnboundID Corp.
003 * All Rights Reserved.
004 */
005 /*
006 * Copyright (C) 2011-2013 UnboundID Corp.
007 *
008 * This program is free software; you can redistribute it and/or modify
009 * it under the terms of the GNU General Public License (GPLv2 only)
010 * or the terms of the GNU Lesser General Public License (LGPLv2.1 only)
011 * as published by the Free Software Foundation.
012 *
013 * This program is distributed in the hope that it will be useful,
014 * but WITHOUT ANY WARRANTY; without even the implied warranty of
015 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
016 * GNU General Public License for more details.
017 *
018 * You should have received a copy of the GNU General Public License
019 * along with this program; if not, see <http://www.gnu.org/licenses>.
020 */
021 package com.unboundid.ldap.listener;
022
023
024
025 import java.util.Collection;
026 import java.util.Collections;
027 import java.util.List;
028 import java.util.Map;
029 import java.util.Set;
030 import java.util.logging.Handler;
031
032 import com.unboundid.ldap.sdk.DN;
033 import com.unboundid.ldap.sdk.LDAPException;
034 import com.unboundid.ldap.sdk.OperationType;
035 import com.unboundid.ldap.sdk.schema.Schema;
036 import com.unboundid.util.NotMutable;
037 import com.unboundid.util.ThreadSafety;
038 import com.unboundid.util.ThreadSafetyLevel;
039
040
041
042 /**
043 * This class provides a read-only representation of an
044 * {@link InMemoryDirectoryServerConfig} object. All methods for reading the
045 * configuration will work the same as they do in the superclass, but any
046 * methods which attempt to alter the configuration will throw an
047 * {@code UnsupportedOperationException}.
048 */
049 @NotMutable()
050 @ThreadSafety(level=ThreadSafetyLevel.NOT_THREADSAFE)
051 public final class ReadOnlyInMemoryDirectoryServerConfig
052 extends InMemoryDirectoryServerConfig
053 {
054 /**
055 * Creates a new read-only representation of an in-memory directory server
056 * config object using the provided configuration.
057 *
058 * @param config The configuration to use for this read-only representation.
059 */
060 public ReadOnlyInMemoryDirectoryServerConfig(
061 final InMemoryDirectoryServerConfig config)
062 {
063 super(config);
064 }
065
066
067
068 /**
069 * {@inheritDoc}
070 */
071 @Override()
072 public DN[] getBaseDNs()
073 {
074 final DN[] origBaseDNs = super.getBaseDNs();
075
076 final DN[] baseDNsCopy = new DN[origBaseDNs.length];
077 System.arraycopy(origBaseDNs, 0, baseDNsCopy, 0, baseDNsCopy.length);
078
079 return baseDNsCopy;
080 }
081
082
083
084 /**
085 * {@inheritDoc} This method will always throw an
086 * {@code UnsupportedOperationException}.
087 *
088 * @throws UnsupportedOperationException To indicate that this object cannot
089 * be altered.
090 */
091 @Override()
092 public void setBaseDNs(final String... baseDNs)
093 throws LDAPException, UnsupportedOperationException
094 {
095 throw new UnsupportedOperationException();
096 }
097
098
099
100 /**
101 * {@inheritDoc} This method will always throw an
102 * {@code UnsupportedOperationException}.
103 *
104 * @throws UnsupportedOperationException To indicate that this object cannot
105 * be altered.
106 */
107 @Override()
108 public void setBaseDNs(final DN... baseDNs)
109 throws LDAPException, UnsupportedOperationException
110 {
111 throw new UnsupportedOperationException();
112 }
113
114
115
116 /**
117 * {@inheritDoc} The returned list will not be modifiable.
118 */
119 @Override()
120 public List<InMemoryListenerConfig> getListenerConfigs()
121 {
122 return Collections.unmodifiableList(super.getListenerConfigs());
123 }
124
125
126
127 /**
128 * {@inheritDoc} This method will always throw an
129 * {@code UnsupportedOperationException}.
130 *
131 * @throws UnsupportedOperationException To indicate that this object cannot
132 * be altered.
133 */
134 @Override()
135 public void setListenerConfigs(
136 final InMemoryListenerConfig... listenerConfigs)
137 throws UnsupportedOperationException
138 {
139 throw new UnsupportedOperationException();
140 }
141
142
143
144 /**
145 * {@inheritDoc} This method will always throw an
146 * {@code UnsupportedOperationException}.
147 *
148 * @throws UnsupportedOperationException To indicate that this object cannot
149 * be altered.
150 */
151 @Override()
152 public void setListenerConfigs(
153 final Collection<InMemoryListenerConfig> listenerConfigs)
154 throws UnsupportedOperationException
155 {
156 throw new UnsupportedOperationException();
157 }
158
159
160
161 /**
162 * {@inheritDoc} The returned set will not be modifiable.
163 */
164 @Override()
165 public Set<OperationType> getAllowedOperationTypes()
166 {
167 return Collections.unmodifiableSet(super.getAllowedOperationTypes());
168 }
169
170
171
172 /**
173 * {@inheritDoc} This method will always throw an
174 * {@code UnsupportedOperationException}.
175 *
176 * @throws UnsupportedOperationException To indicate that this object cannot
177 * be altered.
178 */
179 @Override()
180 public void setAllowedOperationTypes(final OperationType... operationTypes)
181 throws UnsupportedOperationException
182 {
183 throw new UnsupportedOperationException();
184 }
185
186
187
188 /**
189 * {@inheritDoc} This method will always throw an
190 * {@code UnsupportedOperationException}.
191 *
192 * @throws UnsupportedOperationException To indicate that this object cannot
193 * be altered.
194 */
195 @Override()
196 public void setAllowedOperationTypes(
197 final Collection<OperationType> operationTypes)
198 throws UnsupportedOperationException
199 {
200 throw new UnsupportedOperationException();
201 }
202
203
204
205 /**
206 * {@inheritDoc} The returned set will not be modifiable.
207 */
208 @Override()
209 public Set<OperationType> getAuthenticationRequiredOperationTypes()
210 {
211 return Collections.unmodifiableSet(
212 super.getAuthenticationRequiredOperationTypes());
213 }
214
215
216
217 /**
218 * {@inheritDoc} This method will always throw an
219 * {@code UnsupportedOperationException}.
220 *
221 * @throws UnsupportedOperationException To indicate that this object cannot
222 * be altered.
223 */
224 @Override()
225 public void setAuthenticationRequiredOperationTypes(
226 final OperationType... operationTypes)
227 throws UnsupportedOperationException
228 {
229 throw new UnsupportedOperationException();
230 }
231
232
233
234 /**
235 * {@inheritDoc} This method will always throw an
236 * {@code UnsupportedOperationException}.
237 *
238 * @throws UnsupportedOperationException To indicate that this object cannot
239 * be altered.
240 */
241 @Override()
242 public void setAuthenticationRequiredOperationTypes(
243 final Collection<OperationType> operationTypes)
244 throws UnsupportedOperationException
245 {
246 throw new UnsupportedOperationException();
247 }
248
249
250
251 /**
252 * {@inheritDoc} The returned map will not be modifiable.
253 */
254 @Override()
255 public Map<DN,byte[]> getAdditionalBindCredentials()
256 {
257 return Collections.unmodifiableMap(super.getAdditionalBindCredentials());
258 }
259
260
261
262 /**
263 * {@inheritDoc} This method will always throw an
264 * {@code UnsupportedOperationException}.
265 *
266 * @throws UnsupportedOperationException To indicate that this object cannot
267 * be altered.
268 */
269 @Override()
270 public void addAdditionalBindCredentials(final String dn,
271 final String password)
272 throws LDAPException, UnsupportedOperationException
273 {
274 throw new UnsupportedOperationException();
275 }
276
277
278
279 /**
280 * {@inheritDoc} This method will always throw an
281 * {@code UnsupportedOperationException}.
282 *
283 * @throws UnsupportedOperationException To indicate that this object cannot
284 * be altered.
285 */
286 @Override()
287 public void addAdditionalBindCredentials(final String dn,
288 final byte[] password)
289 throws LDAPException, UnsupportedOperationException
290 {
291 throw new UnsupportedOperationException();
292 }
293
294
295
296 /**
297 * {@inheritDoc} This method will always throw an
298 * {@code UnsupportedOperationException}.
299 *
300 * @throws UnsupportedOperationException To indicate that this object cannot
301 * be altered.
302 */
303 @Override()
304 public void setListenerExceptionHandler(
305 final LDAPListenerExceptionHandler exceptionHandler)
306 throws UnsupportedOperationException
307 {
308 throw new UnsupportedOperationException();
309 }
310
311
312
313 /**
314 * {@inheritDoc} This method will always throw an
315 * {@code UnsupportedOperationException}.
316 *
317 * @throws UnsupportedOperationException To indicate that this object cannot
318 * be altered.
319 */
320 @Override()
321 public void setSchema(final Schema schema)
322 throws UnsupportedOperationException
323 {
324 throw new UnsupportedOperationException();
325 }
326
327
328
329 /**
330 * {@inheritDoc} This method will always throw an
331 * {@code UnsupportedOperationException}.
332 */
333 @Override()
334 public void setEnforceAttributeSyntaxCompliance(
335 final boolean enforceAttributeSyntaxCompliance)
336 {
337 throw new UnsupportedOperationException();
338 }
339
340
341
342 /**
343 * {@inheritDoc} This method will always throw an
344 * {@code UnsupportedOperationException}.
345 */
346 @Override()
347 public void setEnforceSingleStructuralObjectClass(
348 final boolean enforceSingleStructuralObjectClass)
349 {
350 throw new UnsupportedOperationException();
351 }
352
353
354
355 /**
356 * {@inheritDoc} This method will always throw an
357 * {@code UnsupportedOperationException}.
358 *
359 * @throws UnsupportedOperationException To indicate that this object cannot
360 * be altered.
361 */
362 @Override()
363 public void setAccessLogHandler(final Handler accessLogHandler)
364 throws UnsupportedOperationException
365 {
366 throw new UnsupportedOperationException();
367 }
368
369
370
371 /**
372 * {@inheritDoc} This method will always throw an
373 * {@code UnsupportedOperationException}.
374 *
375 * @throws UnsupportedOperationException To indicate that this object cannot
376 * be altered.
377 */
378 @Override()
379 public void setLDAPDebugLogHandler(final Handler ldapDebugLogHandler)
380 throws UnsupportedOperationException
381 {
382 throw new UnsupportedOperationException();
383 }
384
385
386
387 /**
388 * {@inheritDoc} The returned list will not be modifiable.
389 */
390 @Override()
391 public List<InMemoryExtendedOperationHandler> getExtendedOperationHandlers()
392 {
393 return Collections.unmodifiableList(super.getExtendedOperationHandlers());
394 }
395
396
397
398 /**
399 * {@inheritDoc} This method will always throw an
400 * {@code UnsupportedOperationException}.
401 *
402 * @throws UnsupportedOperationException To indicate that this object cannot
403 * be altered.
404 */
405 @Override()
406 public void addExtendedOperationHandler(
407 final InMemoryExtendedOperationHandler handler)
408 throws UnsupportedOperationException
409 {
410 throw new UnsupportedOperationException();
411 }
412
413
414
415 /**
416 * {@inheritDoc} The returned list will not be modifiable.
417 */
418 @Override()
419 public List<InMemorySASLBindHandler> getSASLBindHandlers()
420 {
421 return Collections.unmodifiableList(super.getSASLBindHandlers());
422 }
423
424
425
426 /**
427 * {@inheritDoc} This method will always throw an
428 * {@code UnsupportedOperationException}.
429 *
430 * @throws UnsupportedOperationException To indicate that this object cannot
431 * be altered.
432 */
433 @Override()
434 public void addSASLBindHandler(final InMemorySASLBindHandler handler)
435 throws UnsupportedOperationException
436 {
437 throw new UnsupportedOperationException();
438 }
439
440
441
442 /**
443 * {@inheritDoc} This method will always throw an
444 * {@code UnsupportedOperationException}.
445 *
446 * @throws UnsupportedOperationException To indicate that this object cannot
447 * be altered.
448 */
449 @Override()
450 public void setGenerateOperationalAttributes(
451 final boolean generateOperationalAttributes)
452 throws UnsupportedOperationException
453 {
454 throw new UnsupportedOperationException();
455 }
456
457
458
459 /**
460 * {@inheritDoc} This method will always throw an
461 * {@code UnsupportedOperationException}.
462 *
463 * @throws UnsupportedOperationException To indicate that this object cannot
464 * be altered.
465 */
466 @Override()
467 public void setMaxChangeLogEntries(final int maxChangeLogEntries)
468 throws UnsupportedOperationException
469 {
470 throw new UnsupportedOperationException();
471 }
472
473
474
475 /**
476 * {@inheritDoc} The returned list will not be modifiable.
477 */
478 @Override()
479 public List<String> getEqualityIndexAttributes()
480 {
481 return Collections.unmodifiableList(super.getEqualityIndexAttributes());
482 }
483
484
485
486 /**
487 * {@inheritDoc} This method will always throw an
488 * {@code UnsupportedOperationException}.
489 *
490 * @throws UnsupportedOperationException To indicate that this object cannot
491 * be altered.
492 */
493 @Override()
494 public void setEqualityIndexAttributes(
495 final String... equalityIndexAttributes)
496 throws UnsupportedOperationException
497 {
498 throw new UnsupportedOperationException();
499 }
500
501
502
503 /**
504 * {@inheritDoc} This method will always throw an
505 * {@code UnsupportedOperationException}.
506 *
507 * @throws UnsupportedOperationException To indicate that this object cannot
508 * be altered.
509 */
510 @Override()
511 public void setEqualityIndexAttributes(
512 final Collection<String> equalityIndexAttributes)
513 throws UnsupportedOperationException
514 {
515 throw new UnsupportedOperationException();
516 }
517
518
519
520 /**
521 * {@inheritDoc} The returned set will not be modifiable.
522 */
523 @Override()
524 public Set<String> getReferentialIntegrityAttributes()
525 {
526 return Collections.unmodifiableSet(
527 super.getReferentialIntegrityAttributes());
528 }
529
530
531
532 /**
533 * {@inheritDoc} This method will always throw an
534 * {@code UnsupportedOperationException}.
535 *
536 * @throws UnsupportedOperationException To indicate that this object cannot
537 * be altered.
538 */
539 @Override()
540 public void setReferentialIntegrityAttributes(
541 final String... referentialIntegrityAttributes)
542 throws UnsupportedOperationException
543 {
544 throw new UnsupportedOperationException();
545 }
546
547
548
549 /**
550 * {@inheritDoc} This method will always throw an
551 * {@code UnsupportedOperationException}.
552 *
553 * @throws UnsupportedOperationException To indicate that this object cannot
554 * be altered.
555 */
556 @Override()
557 public void setReferentialIntegrityAttributes(
558 final Collection<String> referentialIntegrityAttributes)
559 throws UnsupportedOperationException
560 {
561 throw new UnsupportedOperationException();
562 }
563
564
565
566 /**
567 * {@inheritDoc} This method will always throw an
568 * {@code UnsupportedOperationException}.
569 *
570 * @throws UnsupportedOperationException To indicate that this object cannot
571 * be altered.
572 */
573 @Override()
574 public void setVendorName(final String vendorName)
575 throws UnsupportedOperationException
576 {
577 throw new UnsupportedOperationException();
578 }
579
580
581
582 /**
583 * {@inheritDoc} This method will always throw an
584 * {@code UnsupportedOperationException}.
585 *
586 * @throws UnsupportedOperationException To indicate that this object cannot
587 * be altered.
588 */
589 @Override()
590 public void setVendorVersion(final String vendorVersion)
591 throws UnsupportedOperationException
592 {
593 throw new UnsupportedOperationException();
594 }
595 }