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}