001    /*
002     * Copyright 2011-2015 UnboundID Corp.
003     * All Rights Reserved.
004     */
005    /*
006     * Copyright (C) 2011-2015 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    }