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