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 legal-notices/CDDLv1_0.txt
010 * or http://forgerock.org/license/CDDLv1.0.html.
011 * See the License for the specific language governing permissions
012 * and limitations under the License.
013 *
014 * When distributing Covered Code, include this CDDL HEADER in each
015 * file and include the License file at legal-notices/CDDLv1_0.txt.
016 * If applicable, add the following below this CDDL HEADER, with the
017 * fields enclosed by brackets "[]" replaced with your own identifying
018 * information:
019 *      Portions Copyright [yyyy] [name of copyright owner]
020 *
021 * CDDL HEADER END
022 *
023 *
024 *      Copyright 2008 Sun Microsystems, Inc.
025 */
026package org.forgerock.opendj.server.config.meta;
027
028
029
030import java.util.Collection;
031import java.util.SortedSet;
032import org.forgerock.opendj.config.AdministratorAction;
033import org.forgerock.opendj.config.AliasDefaultBehaviorProvider;
034import org.forgerock.opendj.config.AttributeTypePropertyDefinition;
035import org.forgerock.opendj.config.BooleanPropertyDefinition;
036import org.forgerock.opendj.config.ClassPropertyDefinition;
037import org.forgerock.opendj.config.client.ConcurrentModificationException;
038import org.forgerock.opendj.config.client.ManagedObject;
039import org.forgerock.opendj.config.client.MissingMandatoryPropertiesException;
040import org.forgerock.opendj.config.client.OperationRejectedException;
041import org.forgerock.opendj.config.DefaultBehaviorProvider;
042import org.forgerock.opendj.config.DefinedDefaultBehaviorProvider;
043import org.forgerock.opendj.config.DNPropertyDefinition;
044import org.forgerock.opendj.config.EnumPropertyDefinition;
045import org.forgerock.opendj.config.ManagedObjectAlreadyExistsException;
046import org.forgerock.opendj.config.ManagedObjectDefinition;
047import org.forgerock.opendj.config.PropertyOption;
048import org.forgerock.opendj.config.PropertyProvider;
049import org.forgerock.opendj.config.server.ConfigurationChangeListener;
050import org.forgerock.opendj.config.server.ServerManagedObject;
051import org.forgerock.opendj.config.StringPropertyDefinition;
052import org.forgerock.opendj.config.Tag;
053import org.forgerock.opendj.config.TopCfgDefn;
054import org.forgerock.opendj.config.UndefinedDefaultBehaviorProvider;
055import org.forgerock.opendj.ldap.DN;
056import org.forgerock.opendj.ldap.LdapException;
057import org.forgerock.opendj.ldap.schema.AttributeType;
058import org.forgerock.opendj.server.config.client.VirtualAttributeCfgClient;
059import org.forgerock.opendj.server.config.server.VirtualAttributeCfg;
060
061
062
063/**
064 * An interface for querying the Virtual Attribute managed object
065 * definition meta information.
066 * <p>
067 * Virtual Attributes are responsible for dynamically generating
068 * attribute values that appear in entries but are not persistently
069 * stored in the backend.
070 */
071public final class VirtualAttributeCfgDefn extends ManagedObjectDefinition<VirtualAttributeCfgClient, VirtualAttributeCfg> {
072
073  // The singleton configuration definition instance.
074  private static final VirtualAttributeCfgDefn INSTANCE = new VirtualAttributeCfgDefn();
075
076
077
078  /**
079   * Defines the set of permissable values for the "conflict-behavior" property.
080   * <p>
081   * Specifies the behavior that the server is to exhibit for entries
082   * that already contain one or more real values for the associated
083   * attribute.
084   */
085  public static enum ConflictBehavior {
086
087    /**
088     * Indicates that the virtual attribute provider is to preserve
089     * any real values contained in the entry and merge them with the
090     * set of generated virtual values so that both the real and
091     * virtual values are used.
092     */
093    MERGE_REAL_AND_VIRTUAL("merge-real-and-virtual"),
094
095
096
097    /**
098     * Indicates that any real values contained in the entry are
099     * preserved and used, and virtual values are not generated.
100     */
101    REAL_OVERRIDES_VIRTUAL("real-overrides-virtual"),
102
103
104
105    /**
106     * Indicates that the virtual attribute provider suppresses any
107     * real values contained in the entry and generates virtual values
108     * and uses them.
109     */
110    VIRTUAL_OVERRIDES_REAL("virtual-overrides-real");
111
112
113
114    // String representation of the value.
115    private final String name;
116
117
118
119    // Private constructor.
120    private ConflictBehavior(String name) { this.name = name; }
121
122
123
124    /**
125     * {@inheritDoc}
126     */
127    public String toString() { return name; }
128
129  }
130
131
132
133  /**
134   * Defines the set of permissable values for the "scope" property.
135   * <p>
136   * Specifies the LDAP scope associated with base DNs for entries
137   * that are eligible to use this virtual attribute.
138   */
139  public static enum Scope {
140
141    /**
142     * Search the base object only.
143     */
144    BASE_OBJECT("base-object"),
145
146
147
148    /**
149     * Search the immediate children of the base object but do not
150     * include any of their descendants or the base object itself.
151     */
152    SINGLE_LEVEL("single-level"),
153
154
155
156    /**
157     * Search the entire subtree below the base object but do not
158     * include the base object itself.
159     */
160    SUBORDINATE_SUBTREE("subordinate-subtree"),
161
162
163
164    /**
165     * Search the base object and the entire subtree below the base
166     * object.
167     */
168    WHOLE_SUBTREE("whole-subtree");
169
170
171
172    // String representation of the value.
173    private final String name;
174
175
176
177    // Private constructor.
178    private Scope(String name) { this.name = name; }
179
180
181
182    /**
183     * {@inheritDoc}
184     */
185    public String toString() { return name; }
186
187  }
188
189
190
191  // The "attribute-type" property definition.
192  private static final AttributeTypePropertyDefinition PD_ATTRIBUTE_TYPE;
193
194
195
196  // The "base-dn" property definition.
197  private static final DNPropertyDefinition PD_BASE_DN;
198
199
200
201  // The "conflict-behavior" property definition.
202  private static final EnumPropertyDefinition<ConflictBehavior> PD_CONFLICT_BEHAVIOR;
203
204
205
206  // The "enabled" property definition.
207  private static final BooleanPropertyDefinition PD_ENABLED;
208
209
210
211  // The "filter" property definition.
212  private static final StringPropertyDefinition PD_FILTER;
213
214
215
216  // The "group-dn" property definition.
217  private static final DNPropertyDefinition PD_GROUP_DN;
218
219
220
221  // The "java-class" property definition.
222  private static final ClassPropertyDefinition PD_JAVA_CLASS;
223
224
225
226  // The "scope" property definition.
227  private static final EnumPropertyDefinition<Scope> PD_SCOPE;
228
229
230
231  // Build the "attribute-type" property definition.
232  static {
233      AttributeTypePropertyDefinition.Builder builder = AttributeTypePropertyDefinition.createBuilder(INSTANCE, "attribute-type");
234      builder.setOption(PropertyOption.MANDATORY);
235      builder.setAdministratorAction(new AdministratorAction(AdministratorAction.Type.NONE, INSTANCE, "attribute-type"));
236      builder.setDefaultBehaviorProvider(new UndefinedDefaultBehaviorProvider<AttributeType>());
237      PD_ATTRIBUTE_TYPE = builder.getInstance();
238      INSTANCE.registerPropertyDefinition(PD_ATTRIBUTE_TYPE);
239  }
240
241
242
243  // Build the "base-dn" property definition.
244  static {
245      DNPropertyDefinition.Builder builder = DNPropertyDefinition.createBuilder(INSTANCE, "base-dn");
246      builder.setOption(PropertyOption.MULTI_VALUED);
247      builder.setAdministratorAction(new AdministratorAction(AdministratorAction.Type.NONE, INSTANCE, "base-dn"));
248      builder.setDefaultBehaviorProvider(new AliasDefaultBehaviorProvider<DN>(INSTANCE, "base-dn"));
249      PD_BASE_DN = builder.getInstance();
250      INSTANCE.registerPropertyDefinition(PD_BASE_DN);
251  }
252
253
254
255  // Build the "conflict-behavior" property definition.
256  static {
257      EnumPropertyDefinition.Builder<ConflictBehavior> builder = EnumPropertyDefinition.createBuilder(INSTANCE, "conflict-behavior");
258      builder.setAdministratorAction(new AdministratorAction(AdministratorAction.Type.NONE, INSTANCE, "conflict-behavior"));
259      DefaultBehaviorProvider<ConflictBehavior> provider = new DefinedDefaultBehaviorProvider<ConflictBehavior>("real-overrides-virtual");
260      builder.setDefaultBehaviorProvider(provider);
261      builder.setEnumClass(ConflictBehavior.class);
262      PD_CONFLICT_BEHAVIOR = builder.getInstance();
263      INSTANCE.registerPropertyDefinition(PD_CONFLICT_BEHAVIOR);
264  }
265
266
267
268  // Build the "enabled" property definition.
269  static {
270      BooleanPropertyDefinition.Builder builder = BooleanPropertyDefinition.createBuilder(INSTANCE, "enabled");
271      builder.setOption(PropertyOption.MANDATORY);
272      builder.setAdministratorAction(new AdministratorAction(AdministratorAction.Type.NONE, INSTANCE, "enabled"));
273      builder.setDefaultBehaviorProvider(new UndefinedDefaultBehaviorProvider<Boolean>());
274      PD_ENABLED = builder.getInstance();
275      INSTANCE.registerPropertyDefinition(PD_ENABLED);
276  }
277
278
279
280  // Build the "filter" property definition.
281  static {
282      StringPropertyDefinition.Builder builder = StringPropertyDefinition.createBuilder(INSTANCE, "filter");
283      builder.setOption(PropertyOption.MULTI_VALUED);
284      builder.setAdministratorAction(new AdministratorAction(AdministratorAction.Type.NONE, INSTANCE, "filter"));
285      DefaultBehaviorProvider<String> provider = new DefinedDefaultBehaviorProvider<String>("(objectClass=*)");
286      builder.setDefaultBehaviorProvider(provider);
287      builder.setPattern(".*", "STRING");
288      PD_FILTER = builder.getInstance();
289      INSTANCE.registerPropertyDefinition(PD_FILTER);
290  }
291
292
293
294  // Build the "group-dn" property definition.
295  static {
296      DNPropertyDefinition.Builder builder = DNPropertyDefinition.createBuilder(INSTANCE, "group-dn");
297      builder.setOption(PropertyOption.MULTI_VALUED);
298      builder.setAdministratorAction(new AdministratorAction(AdministratorAction.Type.NONE, INSTANCE, "group-dn"));
299      builder.setDefaultBehaviorProvider(new AliasDefaultBehaviorProvider<DN>(INSTANCE, "group-dn"));
300      PD_GROUP_DN = builder.getInstance();
301      INSTANCE.registerPropertyDefinition(PD_GROUP_DN);
302  }
303
304
305
306  // Build the "java-class" property definition.
307  static {
308      ClassPropertyDefinition.Builder builder = ClassPropertyDefinition.createBuilder(INSTANCE, "java-class");
309      builder.setOption(PropertyOption.MANDATORY);
310      builder.setAdministratorAction(new AdministratorAction(AdministratorAction.Type.COMPONENT_RESTART, INSTANCE, "java-class"));
311      builder.setDefaultBehaviorProvider(new UndefinedDefaultBehaviorProvider<String>());
312      builder.addInstanceOf("org.opends.server.api.VirtualAttributeProvider");
313      PD_JAVA_CLASS = builder.getInstance();
314      INSTANCE.registerPropertyDefinition(PD_JAVA_CLASS);
315  }
316
317
318
319  // Build the "scope" property definition.
320  static {
321      EnumPropertyDefinition.Builder<Scope> builder = EnumPropertyDefinition.createBuilder(INSTANCE, "scope");
322      builder.setAdministratorAction(new AdministratorAction(AdministratorAction.Type.NONE, INSTANCE, "scope"));
323      DefaultBehaviorProvider<Scope> provider = new DefinedDefaultBehaviorProvider<Scope>("whole-subtree");
324      builder.setDefaultBehaviorProvider(provider);
325      builder.setEnumClass(Scope.class);
326      PD_SCOPE = builder.getInstance();
327      INSTANCE.registerPropertyDefinition(PD_SCOPE);
328  }
329
330
331
332  // Register the tags associated with this managed object definition.
333  static {
334    INSTANCE.registerTag(Tag.valueOf("core-server"));
335  }
336
337
338
339  /**
340   * Get the Virtual Attribute configuration definition singleton.
341   *
342   * @return Returns the Virtual Attribute configuration definition
343   *         singleton.
344   */
345  public static VirtualAttributeCfgDefn getInstance() {
346    return INSTANCE;
347  }
348
349
350
351  /**
352   * Private constructor.
353   */
354  private VirtualAttributeCfgDefn() {
355    super("virtual-attribute", TopCfgDefn.getInstance());
356  }
357
358
359
360  /**
361   * {@inheritDoc}
362   */
363  public VirtualAttributeCfgClient createClientConfiguration(
364      ManagedObject<? extends VirtualAttributeCfgClient> impl) {
365    return new VirtualAttributeCfgClientImpl(impl);
366  }
367
368
369
370  /**
371   * {@inheritDoc}
372   */
373  public VirtualAttributeCfg createServerConfiguration(
374      ServerManagedObject<? extends VirtualAttributeCfg> impl) {
375    return new VirtualAttributeCfgServerImpl(impl);
376  }
377
378
379
380  /**
381   * {@inheritDoc}
382   */
383  public Class<VirtualAttributeCfg> getServerConfigurationClass() {
384    return VirtualAttributeCfg.class;
385  }
386
387
388
389  /**
390   * Get the "attribute-type" property definition.
391   * <p>
392   * Specifies the attribute type for the attribute whose values are
393   * to be dynamically assigned by the virtual attribute.
394   *
395   * @return Returns the "attribute-type" property definition.
396   */
397  public AttributeTypePropertyDefinition getAttributeTypePropertyDefinition() {
398    return PD_ATTRIBUTE_TYPE;
399  }
400
401
402
403  /**
404   * Get the "base-dn" property definition.
405   * <p>
406   * Specifies the base DNs for the branches containing entries that
407   * are eligible to use this virtual attribute.
408   * <p>
409   * If no values are given, then the server generates virtual
410   * attributes anywhere in the server.
411   *
412   * @return Returns the "base-dn" property definition.
413   */
414  public DNPropertyDefinition getBaseDNPropertyDefinition() {
415    return PD_BASE_DN;
416  }
417
418
419
420  /**
421   * Get the "conflict-behavior" property definition.
422   * <p>
423   * Specifies the behavior that the server is to exhibit for entries
424   * that already contain one or more real values for the associated
425   * attribute.
426   *
427   * @return Returns the "conflict-behavior" property definition.
428   */
429  public EnumPropertyDefinition<ConflictBehavior> getConflictBehaviorPropertyDefinition() {
430    return PD_CONFLICT_BEHAVIOR;
431  }
432
433
434
435  /**
436   * Get the "enabled" property definition.
437   * <p>
438   * Indicates whether the Virtual Attribute is enabled for use.
439   *
440   * @return Returns the "enabled" property definition.
441   */
442  public BooleanPropertyDefinition getEnabledPropertyDefinition() {
443    return PD_ENABLED;
444  }
445
446
447
448  /**
449   * Get the "filter" property definition.
450   * <p>
451   * Specifies the search filters to be applied against entries to
452   * determine if the virtual attribute is to be generated for those
453   * entries.
454   * <p>
455   * If no values are given, then any entry is eligible to have the
456   * value generated. If one or more filters are specified, then only
457   * entries that match at least one of those filters are allowed to
458   * have the virtual attribute.
459   *
460   * @return Returns the "filter" property definition.
461   */
462  public StringPropertyDefinition getFilterPropertyDefinition() {
463    return PD_FILTER;
464  }
465
466
467
468  /**
469   * Get the "group-dn" property definition.
470   * <p>
471   * Specifies the DNs of the groups whose members can be eligible to
472   * use this virtual attribute.
473   * <p>
474   * If no values are given, then group membership is not taken into
475   * account when generating the virtual attribute. If one or more
476   * group DNs are specified, then only members of those groups are
477   * allowed to have the virtual attribute.
478   *
479   * @return Returns the "group-dn" property definition.
480   */
481  public DNPropertyDefinition getGroupDNPropertyDefinition() {
482    return PD_GROUP_DN;
483  }
484
485
486
487  /**
488   * Get the "java-class" property definition.
489   * <p>
490   * Specifies the fully-qualified name of the virtual attribute
491   * provider class that generates the attribute values.
492   *
493   * @return Returns the "java-class" property definition.
494   */
495  public ClassPropertyDefinition getJavaClassPropertyDefinition() {
496    return PD_JAVA_CLASS;
497  }
498
499
500
501  /**
502   * Get the "scope" property definition.
503   * <p>
504   * Specifies the LDAP scope associated with base DNs for entries
505   * that are eligible to use this virtual attribute.
506   *
507   * @return Returns the "scope" property definition.
508   */
509  public EnumPropertyDefinition<Scope> getScopePropertyDefinition() {
510    return PD_SCOPE;
511  }
512
513
514
515  /**
516   * Managed object client implementation.
517   */
518  private static class VirtualAttributeCfgClientImpl implements
519    VirtualAttributeCfgClient {
520
521    // Private implementation.
522    private ManagedObject<? extends VirtualAttributeCfgClient> impl;
523
524
525
526    // Private constructor.
527    private VirtualAttributeCfgClientImpl(
528        ManagedObject<? extends VirtualAttributeCfgClient> impl) {
529      this.impl = impl;
530    }
531
532
533
534    /**
535     * {@inheritDoc}
536     */
537    public AttributeType getAttributeType() {
538      return impl.getPropertyValue(INSTANCE.getAttributeTypePropertyDefinition());
539    }
540
541
542
543    /**
544     * {@inheritDoc}
545     */
546    public void setAttributeType(AttributeType value) {
547      impl.setPropertyValue(INSTANCE.getAttributeTypePropertyDefinition(), value);
548    }
549
550
551
552    /**
553     * {@inheritDoc}
554     */
555    public SortedSet<DN> getBaseDN() {
556      return impl.getPropertyValues(INSTANCE.getBaseDNPropertyDefinition());
557    }
558
559
560
561    /**
562     * {@inheritDoc}
563     */
564    public void setBaseDN(Collection<DN> values) {
565      impl.setPropertyValues(INSTANCE.getBaseDNPropertyDefinition(), values);
566    }
567
568
569
570    /**
571     * {@inheritDoc}
572     */
573    public ConflictBehavior getConflictBehavior() {
574      return impl.getPropertyValue(INSTANCE.getConflictBehaviorPropertyDefinition());
575    }
576
577
578
579    /**
580     * {@inheritDoc}
581     */
582    public void setConflictBehavior(ConflictBehavior value) {
583      impl.setPropertyValue(INSTANCE.getConflictBehaviorPropertyDefinition(), value);
584    }
585
586
587
588    /**
589     * {@inheritDoc}
590     */
591    public Boolean isEnabled() {
592      return impl.getPropertyValue(INSTANCE.getEnabledPropertyDefinition());
593    }
594
595
596
597    /**
598     * {@inheritDoc}
599     */
600    public void setEnabled(boolean value) {
601      impl.setPropertyValue(INSTANCE.getEnabledPropertyDefinition(), value);
602    }
603
604
605
606    /**
607     * {@inheritDoc}
608     */
609    public SortedSet<String> getFilter() {
610      return impl.getPropertyValues(INSTANCE.getFilterPropertyDefinition());
611    }
612
613
614
615    /**
616     * {@inheritDoc}
617     */
618    public void setFilter(Collection<String> values) {
619      impl.setPropertyValues(INSTANCE.getFilterPropertyDefinition(), values);
620    }
621
622
623
624    /**
625     * {@inheritDoc}
626     */
627    public SortedSet<DN> getGroupDN() {
628      return impl.getPropertyValues(INSTANCE.getGroupDNPropertyDefinition());
629    }
630
631
632
633    /**
634     * {@inheritDoc}
635     */
636    public void setGroupDN(Collection<DN> values) {
637      impl.setPropertyValues(INSTANCE.getGroupDNPropertyDefinition(), values);
638    }
639
640
641
642    /**
643     * {@inheritDoc}
644     */
645    public String getJavaClass() {
646      return impl.getPropertyValue(INSTANCE.getJavaClassPropertyDefinition());
647    }
648
649
650
651    /**
652     * {@inheritDoc}
653     */
654    public void setJavaClass(String value) {
655      impl.setPropertyValue(INSTANCE.getJavaClassPropertyDefinition(), value);
656    }
657
658
659
660    /**
661     * {@inheritDoc}
662     */
663    public Scope getScope() {
664      return impl.getPropertyValue(INSTANCE.getScopePropertyDefinition());
665    }
666
667
668
669    /**
670     * {@inheritDoc}
671     */
672    public void setScope(Scope value) {
673      impl.setPropertyValue(INSTANCE.getScopePropertyDefinition(), value);
674    }
675
676
677
678    /**
679     * {@inheritDoc}
680     */
681    public ManagedObjectDefinition<? extends VirtualAttributeCfgClient, ? extends VirtualAttributeCfg> definition() {
682      return INSTANCE;
683    }
684
685
686
687    /**
688     * {@inheritDoc}
689     */
690    public PropertyProvider properties() {
691      return impl;
692    }
693
694
695
696    /**
697     * {@inheritDoc}
698     */
699    public void commit() throws ManagedObjectAlreadyExistsException,
700        MissingMandatoryPropertiesException, ConcurrentModificationException,
701        OperationRejectedException, LdapException {
702      impl.commit();
703    }
704
705  }
706
707
708
709  /**
710   * Managed object server implementation.
711   */
712  private static class VirtualAttributeCfgServerImpl implements
713    VirtualAttributeCfg {
714
715    // Private implementation.
716    private ServerManagedObject<? extends VirtualAttributeCfg> impl;
717
718    // The value of the "attribute-type" property.
719    private final AttributeType pAttributeType;
720
721    // The value of the "base-dn" property.
722    private final SortedSet<DN> pBaseDN;
723
724    // The value of the "conflict-behavior" property.
725    private final ConflictBehavior pConflictBehavior;
726
727    // The value of the "enabled" property.
728    private final boolean pEnabled;
729
730    // The value of the "filter" property.
731    private final SortedSet<String> pFilter;
732
733    // The value of the "group-dn" property.
734    private final SortedSet<DN> pGroupDN;
735
736    // The value of the "java-class" property.
737    private final String pJavaClass;
738
739    // The value of the "scope" property.
740    private final Scope pScope;
741
742
743
744    // Private constructor.
745    private VirtualAttributeCfgServerImpl(ServerManagedObject<? extends VirtualAttributeCfg> impl) {
746      this.impl = impl;
747      this.pAttributeType = impl.getPropertyValue(INSTANCE.getAttributeTypePropertyDefinition());
748      this.pBaseDN = impl.getPropertyValues(INSTANCE.getBaseDNPropertyDefinition());
749      this.pConflictBehavior = impl.getPropertyValue(INSTANCE.getConflictBehaviorPropertyDefinition());
750      this.pEnabled = impl.getPropertyValue(INSTANCE.getEnabledPropertyDefinition());
751      this.pFilter = impl.getPropertyValues(INSTANCE.getFilterPropertyDefinition());
752      this.pGroupDN = impl.getPropertyValues(INSTANCE.getGroupDNPropertyDefinition());
753      this.pJavaClass = impl.getPropertyValue(INSTANCE.getJavaClassPropertyDefinition());
754      this.pScope = impl.getPropertyValue(INSTANCE.getScopePropertyDefinition());
755    }
756
757
758
759    /**
760     * {@inheritDoc}
761     */
762    public void addChangeListener(
763        ConfigurationChangeListener<VirtualAttributeCfg> listener) {
764      impl.registerChangeListener(listener);
765    }
766
767
768
769    /**
770     * {@inheritDoc}
771     */
772    public void removeChangeListener(
773        ConfigurationChangeListener<VirtualAttributeCfg> listener) {
774      impl.deregisterChangeListener(listener);
775    }
776
777
778
779    /**
780     * {@inheritDoc}
781     */
782    public AttributeType getAttributeType() {
783      return pAttributeType;
784    }
785
786
787
788    /**
789     * {@inheritDoc}
790     */
791    public SortedSet<DN> getBaseDN() {
792      return pBaseDN;
793    }
794
795
796
797    /**
798     * {@inheritDoc}
799     */
800    public ConflictBehavior getConflictBehavior() {
801      return pConflictBehavior;
802    }
803
804
805
806    /**
807     * {@inheritDoc}
808     */
809    public boolean isEnabled() {
810      return pEnabled;
811    }
812
813
814
815    /**
816     * {@inheritDoc}
817     */
818    public SortedSet<String> getFilter() {
819      return pFilter;
820    }
821
822
823
824    /**
825     * {@inheritDoc}
826     */
827    public SortedSet<DN> getGroupDN() {
828      return pGroupDN;
829    }
830
831
832
833    /**
834     * {@inheritDoc}
835     */
836    public String getJavaClass() {
837      return pJavaClass;
838    }
839
840
841
842    /**
843     * {@inheritDoc}
844     */
845    public Scope getScope() {
846      return pScope;
847    }
848
849
850
851    /**
852     * {@inheritDoc}
853     */
854    public Class<? extends VirtualAttributeCfg> configurationClass() {
855      return VirtualAttributeCfg.class;
856    }
857
858
859
860    /**
861     * {@inheritDoc}
862     */
863    public DN dn() {
864      return impl.getDN();
865    }
866
867  }
868}