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