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