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.admin.std.meta;
028    
029    
030    
031    import java.util.Collection;
032    import java.util.SortedSet;
033    import org.opends.server.admin.AdministratorAction;
034    import org.opends.server.admin.AliasDefaultBehaviorProvider;
035    import org.opends.server.admin.BooleanPropertyDefinition;
036    import org.opends.server.admin.client.AuthorizationException;
037    import org.opends.server.admin.client.CommunicationException;
038    import org.opends.server.admin.client.ConcurrentModificationException;
039    import org.opends.server.admin.client.ManagedObject;
040    import org.opends.server.admin.client.MissingMandatoryPropertiesException;
041    import org.opends.server.admin.client.OperationRejectedException;
042    import org.opends.server.admin.DefaultBehaviorProvider;
043    import org.opends.server.admin.DefinedDefaultBehaviorProvider;
044    import org.opends.server.admin.EnumPropertyDefinition;
045    import org.opends.server.admin.IntegerPropertyDefinition;
046    import org.opends.server.admin.ManagedObjectAlreadyExistsException;
047    import org.opends.server.admin.ManagedObjectDefinition;
048    import org.opends.server.admin.PropertyIsReadOnlyException;
049    import org.opends.server.admin.PropertyOption;
050    import org.opends.server.admin.PropertyProvider;
051    import org.opends.server.admin.server.ConfigurationChangeListener;
052    import org.opends.server.admin.server.ServerManagedObject;
053    import org.opends.server.admin.std.client.DebugTargetCfgClient;
054    import org.opends.server.admin.std.server.DebugTargetCfg;
055    import org.opends.server.admin.StringPropertyDefinition;
056    import org.opends.server.admin.Tag;
057    import org.opends.server.admin.TopCfgDefn;
058    import org.opends.server.admin.UndefinedDefaultBehaviorProvider;
059    import org.opends.server.types.DN;
060    
061    
062    
063    /**
064     * An interface for querying the Debug Target managed object
065     * definition meta information.
066     * <p>
067     * Debug Targets define the types of messages logged by the debug
068     * logPublisher.
069     */
070    public final class DebugTargetCfgDefn extends ManagedObjectDefinition<DebugTargetCfgClient, DebugTargetCfg> {
071    
072      // The singleton configuration definition instance.
073      private static final DebugTargetCfgDefn INSTANCE = new DebugTargetCfgDefn();
074    
075    
076    
077      /**
078       * Defines the set of permissable values for the "debug-category" property.
079       * <p>
080       * Specifies the debug message categories to be logged.
081       */
082      public static enum DebugCategory {
083    
084        /**
085         * Exception caught
086         */
087        CAUGHT("caught"),
088    
089    
090    
091        /**
092         * Constructor entry
093         */
094        CONSTRUCTOR("constructor"),
095    
096    
097    
098        /**
099         * Raw data dump
100         */
101        DATA("data"),
102    
103    
104    
105        /**
106         * Access to a backend database.
107         */
108        DATABASE_ACCESS("database-access"),
109    
110    
111    
112        /**
113         * Method entry
114         */
115        ENTER("enter"),
116    
117    
118    
119        /**
120         * Method exit
121         */
122        EXIT("exit"),
123    
124    
125    
126        /**
127         * Arbitrary debug message
128         */
129        MESSAGE("message"),
130    
131    
132    
133        /**
134         * Protocol element dump
135         */
136        PROTOCOL("protocol"),
137    
138    
139    
140        /**
141         * Exception throw from method
142         */
143        THROWN("thrown");
144    
145    
146    
147        // String representation of the value.
148        private final String name;
149    
150    
151    
152        // Private constructor.
153        private DebugCategory(String name) { this.name = name; }
154    
155    
156    
157        /**
158         * {@inheritDoc}
159         */
160        public String toString() { return name; }
161    
162      }
163    
164    
165    
166      /**
167       * Defines the set of permissable values for the "debug-level" property.
168       * <p>
169       * Specifies the lowest severity level of debug messages to log.
170       */
171      public static enum DebugLevel {
172    
173        /**
174         * Messages with any severity level are logged.
175         */
176        ALL("all"),
177    
178    
179    
180        /**
181         * No messages are logged.
182         */
183        DISABLED("disabled"),
184    
185    
186    
187        /**
188         * Messages with severity level of ERROR or higher are logged.
189         */
190        ERROR("error"),
191    
192    
193    
194        /**
195         * Messages with severity level of INFO or higher are logged.
196         */
197        INFO("info"),
198    
199    
200    
201        /**
202         * Messages with severity level of VERBOSE or higher are logged.
203         */
204        VERBOSE("verbose"),
205    
206    
207    
208        /**
209         * Messages with severity level of WARNING or higher are logged.
210         */
211        WARNING("warning");
212    
213    
214    
215        // String representation of the value.
216        private final String name;
217    
218    
219    
220        // Private constructor.
221        private DebugLevel(String name) { this.name = name; }
222    
223    
224    
225        /**
226         * {@inheritDoc}
227         */
228        public String toString() { return name; }
229    
230      }
231    
232    
233    
234      // The "debug-category" property definition.
235      private static final EnumPropertyDefinition<DebugCategory> PD_DEBUG_CATEGORY;
236    
237    
238    
239      // The "debug-level" property definition.
240      private static final EnumPropertyDefinition<DebugLevel> PD_DEBUG_LEVEL;
241    
242    
243    
244      // The "debug-scope" property definition.
245      private static final StringPropertyDefinition PD_DEBUG_SCOPE;
246    
247    
248    
249      // The "include-throwable-cause" property definition.
250      private static final BooleanPropertyDefinition PD_INCLUDE_THROWABLE_CAUSE;
251    
252    
253    
254      // The "omit-method-entry-arguments" property definition.
255      private static final BooleanPropertyDefinition PD_OMIT_METHOD_ENTRY_ARGUMENTS;
256    
257    
258    
259      // The "omit-method-return-value" property definition.
260      private static final BooleanPropertyDefinition PD_OMIT_METHOD_RETURN_VALUE;
261    
262    
263    
264      // The "throwable-stack-frames" property definition.
265      private static final IntegerPropertyDefinition PD_THROWABLE_STACK_FRAMES;
266    
267    
268    
269      // Build the "debug-category" property definition.
270      static {
271          EnumPropertyDefinition.Builder<DebugCategory> builder = EnumPropertyDefinition.createBuilder(INSTANCE, "debug-category");
272          builder.setOption(PropertyOption.MULTI_VALUED);
273          builder.setAdministratorAction(new AdministratorAction(AdministratorAction.Type.NONE, INSTANCE, "debug-category"));
274          builder.setDefaultBehaviorProvider(new AliasDefaultBehaviorProvider<DebugCategory>(INSTANCE, "debug-category"));
275          builder.setEnumClass(DebugCategory.class);
276          PD_DEBUG_CATEGORY = builder.getInstance();
277          INSTANCE.registerPropertyDefinition(PD_DEBUG_CATEGORY);
278      }
279    
280    
281    
282      // Build the "debug-level" property definition.
283      static {
284          EnumPropertyDefinition.Builder<DebugLevel> builder = EnumPropertyDefinition.createBuilder(INSTANCE, "debug-level");
285          builder.setOption(PropertyOption.MANDATORY);
286          builder.setAdministratorAction(new AdministratorAction(AdministratorAction.Type.NONE, INSTANCE, "debug-level"));
287          builder.setDefaultBehaviorProvider(new UndefinedDefaultBehaviorProvider<DebugLevel>());
288          builder.setEnumClass(DebugLevel.class);
289          PD_DEBUG_LEVEL = builder.getInstance();
290          INSTANCE.registerPropertyDefinition(PD_DEBUG_LEVEL);
291      }
292    
293    
294    
295      // Build the "debug-scope" property definition.
296      static {
297          StringPropertyDefinition.Builder builder = StringPropertyDefinition.createBuilder(INSTANCE, "debug-scope");
298          builder.setOption(PropertyOption.READ_ONLY);
299          builder.setOption(PropertyOption.MANDATORY);
300          builder.setAdministratorAction(new AdministratorAction(AdministratorAction.Type.NONE, INSTANCE, "debug-scope"));
301          builder.setDefaultBehaviorProvider(new UndefinedDefaultBehaviorProvider<String>());
302          builder.setPattern("^([A-Za-z][A-Za-z0-9_]*\\.)*[A-Za-z][A-Za-z0-9_]*(#[A-Za-z][A-Za-z0-9_]*)?$", "STRING");
303          PD_DEBUG_SCOPE = builder.getInstance();
304          INSTANCE.registerPropertyDefinition(PD_DEBUG_SCOPE);
305      }
306    
307    
308    
309      // Build the "include-throwable-cause" property definition.
310      static {
311          BooleanPropertyDefinition.Builder builder = BooleanPropertyDefinition.createBuilder(INSTANCE, "include-throwable-cause");
312          builder.setAdministratorAction(new AdministratorAction(AdministratorAction.Type.NONE, INSTANCE, "include-throwable-cause"));
313          DefaultBehaviorProvider<Boolean> provider = new DefinedDefaultBehaviorProvider<Boolean>("false");
314          builder.setDefaultBehaviorProvider(provider);
315          PD_INCLUDE_THROWABLE_CAUSE = builder.getInstance();
316          INSTANCE.registerPropertyDefinition(PD_INCLUDE_THROWABLE_CAUSE);
317      }
318    
319    
320    
321      // Build the "omit-method-entry-arguments" property definition.
322      static {
323          BooleanPropertyDefinition.Builder builder = BooleanPropertyDefinition.createBuilder(INSTANCE, "omit-method-entry-arguments");
324          builder.setAdministratorAction(new AdministratorAction(AdministratorAction.Type.NONE, INSTANCE, "omit-method-entry-arguments"));
325          DefaultBehaviorProvider<Boolean> provider = new DefinedDefaultBehaviorProvider<Boolean>("false");
326          builder.setDefaultBehaviorProvider(provider);
327          PD_OMIT_METHOD_ENTRY_ARGUMENTS = builder.getInstance();
328          INSTANCE.registerPropertyDefinition(PD_OMIT_METHOD_ENTRY_ARGUMENTS);
329      }
330    
331    
332    
333      // Build the "omit-method-return-value" property definition.
334      static {
335          BooleanPropertyDefinition.Builder builder = BooleanPropertyDefinition.createBuilder(INSTANCE, "omit-method-return-value");
336          builder.setAdministratorAction(new AdministratorAction(AdministratorAction.Type.NONE, INSTANCE, "omit-method-return-value"));
337          DefaultBehaviorProvider<Boolean> provider = new DefinedDefaultBehaviorProvider<Boolean>("false");
338          builder.setDefaultBehaviorProvider(provider);
339          PD_OMIT_METHOD_RETURN_VALUE = builder.getInstance();
340          INSTANCE.registerPropertyDefinition(PD_OMIT_METHOD_RETURN_VALUE);
341      }
342    
343    
344    
345      // Build the "throwable-stack-frames" property definition.
346      static {
347          IntegerPropertyDefinition.Builder builder = IntegerPropertyDefinition.createBuilder(INSTANCE, "throwable-stack-frames");
348          builder.setAdministratorAction(new AdministratorAction(AdministratorAction.Type.NONE, INSTANCE, "throwable-stack-frames"));
349          DefaultBehaviorProvider<Integer> provider = new DefinedDefaultBehaviorProvider<Integer>("0");
350          builder.setDefaultBehaviorProvider(provider);
351          builder.setLowerLimit(0);
352          PD_THROWABLE_STACK_FRAMES = builder.getInstance();
353          INSTANCE.registerPropertyDefinition(PD_THROWABLE_STACK_FRAMES);
354      }
355    
356    
357    
358      // Register the tags associated with this managed object definition.
359      static {
360        INSTANCE.registerTag(Tag.valueOf("logging"));
361      }
362    
363    
364    
365      /**
366       * Get the Debug Target configuration definition singleton.
367       *
368       * @return Returns the Debug Target configuration definition
369       *         singleton.
370       */
371      public static DebugTargetCfgDefn getInstance() {
372        return INSTANCE;
373      }
374    
375    
376    
377      /**
378       * Private constructor.
379       */
380      private DebugTargetCfgDefn() {
381        super("debug-target", TopCfgDefn.getInstance());
382      }
383    
384    
385    
386      /**
387       * {@inheritDoc}
388       */
389      public DebugTargetCfgClient createClientConfiguration(
390          ManagedObject<? extends DebugTargetCfgClient> impl) {
391        return new DebugTargetCfgClientImpl(impl);
392      }
393    
394    
395    
396      /**
397       * {@inheritDoc}
398       */
399      public DebugTargetCfg createServerConfiguration(
400          ServerManagedObject<? extends DebugTargetCfg> impl) {
401        return new DebugTargetCfgServerImpl(impl);
402      }
403    
404    
405    
406      /**
407       * {@inheritDoc}
408       */
409      public Class<DebugTargetCfg> getServerConfigurationClass() {
410        return DebugTargetCfg.class;
411      }
412    
413    
414    
415      /**
416       * Get the "debug-category" property definition.
417       * <p>
418       * Specifies the debug message categories to be logged.
419       *
420       * @return Returns the "debug-category" property definition.
421       */
422      public EnumPropertyDefinition<DebugCategory> getDebugCategoryPropertyDefinition() {
423        return PD_DEBUG_CATEGORY;
424      }
425    
426    
427    
428      /**
429       * Get the "debug-level" property definition.
430       * <p>
431       * Specifies the lowest severity level of debug messages to log.
432       *
433       * @return Returns the "debug-level" property definition.
434       */
435      public EnumPropertyDefinition<DebugLevel> getDebugLevelPropertyDefinition() {
436        return PD_DEBUG_LEVEL;
437      }
438    
439    
440    
441      /**
442       * Get the "debug-scope" property definition.
443       * <p>
444       * Specifies the fully-qualified OpenDS Java package, class, or
445       * method affected by the settings in this target definition. Use the
446       * number character (#) to separate the class name and the method
447       * name (that is, org.opends.server.core.DirectoryServer#startUp).
448       *
449       * @return Returns the "debug-scope" property definition.
450       */
451      public StringPropertyDefinition getDebugScopePropertyDefinition() {
452        return PD_DEBUG_SCOPE;
453      }
454    
455    
456    
457      /**
458       * Get the "include-throwable-cause" property definition.
459       * <p>
460       * Specifies the property to indicate whether to include the cause
461       * of exceptions in exception thrown and caught messages.
462       *
463       * @return Returns the "include-throwable-cause" property definition.
464       */
465      public BooleanPropertyDefinition getIncludeThrowableCausePropertyDefinition() {
466        return PD_INCLUDE_THROWABLE_CAUSE;
467      }
468    
469    
470    
471      /**
472       * Get the "omit-method-entry-arguments" property definition.
473       * <p>
474       * Specifies the property to indicate whether to include method
475       * arguments in debug messages.
476       *
477       * @return Returns the "omit-method-entry-arguments" property definition.
478       */
479      public BooleanPropertyDefinition getOmitMethodEntryArgumentsPropertyDefinition() {
480        return PD_OMIT_METHOD_ENTRY_ARGUMENTS;
481      }
482    
483    
484    
485      /**
486       * Get the "omit-method-return-value" property definition.
487       * <p>
488       * Specifies the property to indicate whether to include the return
489       * value in debug messages.
490       *
491       * @return Returns the "omit-method-return-value" property definition.
492       */
493      public BooleanPropertyDefinition getOmitMethodReturnValuePropertyDefinition() {
494        return PD_OMIT_METHOD_RETURN_VALUE;
495      }
496    
497    
498    
499      /**
500       * Get the "throwable-stack-frames" property definition.
501       * <p>
502       * Specifies the property to indicate the number of stack frames to
503       * include in the stack trace for method entry and exception thrown
504       * messages.
505       *
506       * @return Returns the "throwable-stack-frames" property definition.
507       */
508      public IntegerPropertyDefinition getThrowableStackFramesPropertyDefinition() {
509        return PD_THROWABLE_STACK_FRAMES;
510      }
511    
512    
513    
514      /**
515       * Managed object client implementation.
516       */
517      private static class DebugTargetCfgClientImpl implements
518        DebugTargetCfgClient {
519    
520        // Private implementation.
521        private ManagedObject<? extends DebugTargetCfgClient> impl;
522    
523    
524    
525        // Private constructor.
526        private DebugTargetCfgClientImpl(
527            ManagedObject<? extends DebugTargetCfgClient> impl) {
528          this.impl = impl;
529        }
530    
531    
532    
533        /**
534         * {@inheritDoc}
535         */
536        public SortedSet<DebugCategory> getDebugCategory() {
537          return impl.getPropertyValues(INSTANCE.getDebugCategoryPropertyDefinition());
538        }
539    
540    
541    
542        /**
543         * {@inheritDoc}
544         */
545        public void setDebugCategory(Collection<DebugCategory> values) {
546          impl.setPropertyValues(INSTANCE.getDebugCategoryPropertyDefinition(), values);
547        }
548    
549    
550    
551        /**
552         * {@inheritDoc}
553         */
554        public DebugLevel getDebugLevel() {
555          return impl.getPropertyValue(INSTANCE.getDebugLevelPropertyDefinition());
556        }
557    
558    
559    
560        /**
561         * {@inheritDoc}
562         */
563        public void setDebugLevel(DebugLevel value) {
564          impl.setPropertyValue(INSTANCE.getDebugLevelPropertyDefinition(), value);
565        }
566    
567    
568    
569        /**
570         * {@inheritDoc}
571         */
572        public String getDebugScope() {
573          return impl.getPropertyValue(INSTANCE.getDebugScopePropertyDefinition());
574        }
575    
576    
577    
578        /**
579         * {@inheritDoc}
580         */
581        public void setDebugScope(String value) throws PropertyIsReadOnlyException {
582          impl.setPropertyValue(INSTANCE.getDebugScopePropertyDefinition(), value);
583        }
584    
585    
586    
587        /**
588         * {@inheritDoc}
589         */
590        public boolean isIncludeThrowableCause() {
591          return impl.getPropertyValue(INSTANCE.getIncludeThrowableCausePropertyDefinition());
592        }
593    
594    
595    
596        /**
597         * {@inheritDoc}
598         */
599        public void setIncludeThrowableCause(Boolean value) {
600          impl.setPropertyValue(INSTANCE.getIncludeThrowableCausePropertyDefinition(), value);
601        }
602    
603    
604    
605        /**
606         * {@inheritDoc}
607         */
608        public boolean isOmitMethodEntryArguments() {
609          return impl.getPropertyValue(INSTANCE.getOmitMethodEntryArgumentsPropertyDefinition());
610        }
611    
612    
613    
614        /**
615         * {@inheritDoc}
616         */
617        public void setOmitMethodEntryArguments(Boolean value) {
618          impl.setPropertyValue(INSTANCE.getOmitMethodEntryArgumentsPropertyDefinition(), value);
619        }
620    
621    
622    
623        /**
624         * {@inheritDoc}
625         */
626        public boolean isOmitMethodReturnValue() {
627          return impl.getPropertyValue(INSTANCE.getOmitMethodReturnValuePropertyDefinition());
628        }
629    
630    
631    
632        /**
633         * {@inheritDoc}
634         */
635        public void setOmitMethodReturnValue(Boolean value) {
636          impl.setPropertyValue(INSTANCE.getOmitMethodReturnValuePropertyDefinition(), value);
637        }
638    
639    
640    
641        /**
642         * {@inheritDoc}
643         */
644        public int getThrowableStackFrames() {
645          return impl.getPropertyValue(INSTANCE.getThrowableStackFramesPropertyDefinition());
646        }
647    
648    
649    
650        /**
651         * {@inheritDoc}
652         */
653        public void setThrowableStackFrames(Integer value) {
654          impl.setPropertyValue(INSTANCE.getThrowableStackFramesPropertyDefinition(), value);
655        }
656    
657    
658    
659        /**
660         * {@inheritDoc}
661         */
662        public ManagedObjectDefinition<? extends DebugTargetCfgClient, ? extends DebugTargetCfg> definition() {
663          return INSTANCE;
664        }
665    
666    
667    
668        /**
669         * {@inheritDoc}
670         */
671        public PropertyProvider properties() {
672          return impl;
673        }
674    
675    
676    
677        /**
678         * {@inheritDoc}
679         */
680        public void commit() throws ManagedObjectAlreadyExistsException,
681            MissingMandatoryPropertiesException, ConcurrentModificationException,
682            OperationRejectedException, AuthorizationException,
683            CommunicationException {
684          impl.commit();
685        }
686    
687      }
688    
689    
690    
691      /**
692       * Managed object server implementation.
693       */
694      private static class DebugTargetCfgServerImpl implements
695        DebugTargetCfg {
696    
697        // Private implementation.
698        private ServerManagedObject<? extends DebugTargetCfg> impl;
699    
700        // The value of the "debug-category" property.
701        private final SortedSet<DebugCategory> pDebugCategory;
702    
703        // The value of the "debug-level" property.
704        private final DebugLevel pDebugLevel;
705    
706        // The value of the "debug-scope" property.
707        private final String pDebugScope;
708    
709        // The value of the "include-throwable-cause" property.
710        private final boolean pIncludeThrowableCause;
711    
712        // The value of the "omit-method-entry-arguments" property.
713        private final boolean pOmitMethodEntryArguments;
714    
715        // The value of the "omit-method-return-value" property.
716        private final boolean pOmitMethodReturnValue;
717    
718        // The value of the "throwable-stack-frames" property.
719        private final int pThrowableStackFrames;
720    
721    
722    
723        // Private constructor.
724        private DebugTargetCfgServerImpl(ServerManagedObject<? extends DebugTargetCfg> impl) {
725          this.impl = impl;
726          this.pDebugCategory = impl.getPropertyValues(INSTANCE.getDebugCategoryPropertyDefinition());
727          this.pDebugLevel = impl.getPropertyValue(INSTANCE.getDebugLevelPropertyDefinition());
728          this.pDebugScope = impl.getPropertyValue(INSTANCE.getDebugScopePropertyDefinition());
729          this.pIncludeThrowableCause = impl.getPropertyValue(INSTANCE.getIncludeThrowableCausePropertyDefinition());
730          this.pOmitMethodEntryArguments = impl.getPropertyValue(INSTANCE.getOmitMethodEntryArgumentsPropertyDefinition());
731          this.pOmitMethodReturnValue = impl.getPropertyValue(INSTANCE.getOmitMethodReturnValuePropertyDefinition());
732          this.pThrowableStackFrames = impl.getPropertyValue(INSTANCE.getThrowableStackFramesPropertyDefinition());
733        }
734    
735    
736    
737        /**
738         * {@inheritDoc}
739         */
740        public void addChangeListener(
741            ConfigurationChangeListener<DebugTargetCfg> listener) {
742          impl.registerChangeListener(listener);
743        }
744    
745    
746    
747        /**
748         * {@inheritDoc}
749         */
750        public void removeChangeListener(
751            ConfigurationChangeListener<DebugTargetCfg> listener) {
752          impl.deregisterChangeListener(listener);
753        }
754    
755    
756    
757        /**
758         * {@inheritDoc}
759         */
760        public SortedSet<DebugCategory> getDebugCategory() {
761          return pDebugCategory;
762        }
763    
764    
765    
766        /**
767         * {@inheritDoc}
768         */
769        public DebugLevel getDebugLevel() {
770          return pDebugLevel;
771        }
772    
773    
774    
775        /**
776         * {@inheritDoc}
777         */
778        public String getDebugScope() {
779          return pDebugScope;
780        }
781    
782    
783    
784        /**
785         * {@inheritDoc}
786         */
787        public boolean isIncludeThrowableCause() {
788          return pIncludeThrowableCause;
789        }
790    
791    
792    
793        /**
794         * {@inheritDoc}
795         */
796        public boolean isOmitMethodEntryArguments() {
797          return pOmitMethodEntryArguments;
798        }
799    
800    
801    
802        /**
803         * {@inheritDoc}
804         */
805        public boolean isOmitMethodReturnValue() {
806          return pOmitMethodReturnValue;
807        }
808    
809    
810    
811        /**
812         * {@inheritDoc}
813         */
814        public int getThrowableStackFrames() {
815          return pThrowableStackFrames;
816        }
817    
818    
819    
820        /**
821         * {@inheritDoc}
822         */
823        public Class<? extends DebugTargetCfg> configurationClass() {
824          return DebugTargetCfg.class;
825        }
826    
827    
828    
829        /**
830         * {@inheritDoc}
831         */
832        public DN dn() {
833          return impl.getDN();
834        }
835    
836      }
837    }