How to use

ReadCapabilityType

in

com.evolveum.midpoint.xml.ns._public.resource.capabilities_3

/**
 * Create an instance of {@link ReadCapabilityType }
 * 
 */
public ReadCapabilityType createReadCapabilityType() {
  return new ReadCapabilityType();
}

/**
 * Creates a new {@code ReadCapabilityType} instance by deeply copying a given {@code ReadCapabilityType} instance.
 * 
 * 
 * @param o
 *     The instance to copy.
 * @throws NullPointerException
 *     if {@code o} is {@code null}.
 */
public ReadCapabilityType(final ReadCapabilityType o) {
  // CC-XJC Version 2.0 Build 2011-09-16T18:27:24+0000
  super(o);
  if (o == null) {
    throw new NullPointerException("Cannot create a copy of 'ReadCapabilityType' from 'null'.");
  }
  // CBuiltinLeafInfo: java.lang.Boolean
  this.cachingOnly = ((o.cachingOnly == null)?null:o.isCachingOnly());
  // CBuiltinLeafInfo: java.lang.Boolean
  this.returnDefaultAttributesOption = ((o.returnDefaultAttributesOption == null)?null:o.isReturnDefaultAttributesOption());
}

public ReadCapabilityType cachingOnly(Boolean value) {
  setCachingOnly(value);
  return this;
}

public static boolean resourceReadIsCachingOnly(ResourceType resource) {
  ReadCapabilityType readCapabilityType = ResourceTypeUtil.getEffectiveCapability(resource, ReadCapabilityType.class);
  if (readCapabilityType == null) {
    return false;		// TODO reconsider this
  }
  return Boolean.TRUE.equals(readCapabilityType.isCachingOnly());
}
 

ReadCapabilityType readCap = new ReadCapabilityType();
readCap.setCachingOnly(true);
capabilities.add(CAPABILITY_OBJECT_FACTORY.createRead(readCap));

ReadCapabilityType capRead = new ReadCapabilityType();
capRead.setReturnDefaultAttributesOption(supportsReturnDefaultAttributes);
capabilities.add(CAPABILITY_OBJECT_FACTORY.createRead(capRead));

private boolean supportsReturnDefaultAttributes() {
  ReadCapabilityType capability = CapabilityUtil.getCapability(capabilities, ReadCapabilityType.class);
  if (capability == null) {
    return false;
  }
  return Boolean.TRUE.equals(capability.isReturnDefaultAttributesOption());
}

public ReadCapabilityType returnDefaultAttributesOption(Boolean value) {
  setReturnDefaultAttributesOption(value);
  return this;
}

public boolean equals(Object object) {
  final EqualsStrategy strategy = DomAwareEqualsStrategy.INSTANCE;
  return equals(null, null, object, strategy);
}

/**
 * Explicitly check the capability of the resource (primary connector), not capabilities of additional connectors
 */
public static boolean isPrimaryCachingOnly(ResourceType resource) {
  ReadCapabilityType readCapabilityType = CapabilityUtil.getEffectiveCapability(resource.getCapabilities(), ReadCapabilityType.class);
  if (readCapabilityType == null) {
    return false;
  }
  if (!CapabilityUtil.isCapabilityEnabled(readCapabilityType)) {
    return false;
  }
  return Boolean.TRUE.equals(readCapabilityType.isCachingOnly());
}
 

/**
 * Creates and returns a deep copy of this object.
 * 
 * 
 * @return
 *     A deep copy of this object.
 */
@Override
public ReadCapabilityType clone() {
  {
    // CC-XJC Version 2.0 Build 2011-09-16T18:27:24+0000
    final ReadCapabilityType clone = ((ReadCapabilityType) super.clone());
    // CBuiltinLeafInfo: java.lang.Boolean
    clone.cachingOnly = ((this.cachingOnly == null)?null:this.isCachingOnly());
    // CBuiltinLeafInfo: java.lang.Boolean
    clone.returnDefaultAttributesOption = ((this.returnDefaultAttributesOption == null)?null:this.isReturnDefaultAttributesOption());
    return clone;
  }
}

/**
 * Create an instance of {@link ReadCapabilityType }
 * 
 */
public ReadCapabilityType createReadCapabilityType() {
  return new ReadCapabilityType();
}

public static CachingStategyType getCachingStrategy(ProvisioningContext ctx)
    throws ObjectNotFoundException, SchemaException, CommunicationException, ConfigurationException, ExpressionEvaluationException {
  ResourceType resource = ctx.getResource();
  CachingPolicyType caching = resource.getCaching();
  if (caching == null || caching.getCachingStategy() == null) {
    ReadCapabilityType readCapabilityType = ResourceTypeUtil.getEffectiveCapability(resource, ReadCapabilityType.class);
    if (readCapabilityType == null) {
      return CachingStategyType.NONE;
    }
    Boolean cachingOnly = readCapabilityType.isCachingOnly();
    if (cachingOnly == Boolean.TRUE) {
      return CachingStategyType.PASSIVE;
    }
    return CachingStategyType.NONE;
  }
  return caching.getCachingStategy();
}

public int hashCode(ObjectLocator locator, HashCodeStrategy strategy) {
  int currentHashCode = super.hashCode(locator, strategy);
  {
    Boolean theCachingOnly;
    theCachingOnly = this.isCachingOnly();
    currentHashCode = strategy.hashCode(LocatorUtils.property(locator, "cachingOnly", theCachingOnly), currentHashCode, theCachingOnly);
  }
  {
    Boolean theReturnDefaultAttributesOption;
    theReturnDefaultAttributesOption = this.isReturnDefaultAttributesOption();
    currentHashCode = strategy.hashCode(LocatorUtils.property(locator, "returnDefaultAttributesOption", theReturnDefaultAttributesOption), currentHashCode, theReturnDefaultAttributesOption);
  }
  return currentHashCode;
}

/**
 * Create an instance of {@link ReadCapabilityType }
 * 
 */
public ReadCapabilityType createReadCapabilityType() {
  return new ReadCapabilityType();
}

@Test
public void test006Capabilities() throws Exception {
  final String TEST_NAME = "test006Capabilities";
  TestUtil.displayTestTitle(TEST_NAME);
  // GIVEN
  OperationResult result = new OperationResult(TestOpenDj.class.getName()+"."+TEST_NAME);
  // WHEN
  ResourceType resource = provisioningService.getObject(ResourceType.class, getResourceOid(), null, null, result).asObjectable();
  // THEN
  display("Resource from provisioninig", resource);
  display("Resource from provisioninig (XML)", PrismTestUtil.serializeObjectToString(resource.asPrismObject(), PrismContext.LANG_XML));
  CapabilityCollectionType nativeCapabilities = resource.getCapabilities().getNative();
  List<Object> nativeCapabilitiesList = nativeCapabilities.getAny();
  assertFalse("Empty capabilities returned",nativeCapabilitiesList.isEmpty());
  CreateCapabilityType capCreate = CapabilityUtil.getCapability(nativeCapabilitiesList, CreateCapabilityType.class);
  assertNotNull("Missing create capability", capCreate);
  assertManual(capCreate);
  ActivationCapabilityType capAct = CapabilityUtil.getCapability(nativeCapabilitiesList, ActivationCapabilityType.class);
  assertNotNull("Missing activation capability", capAct);
  ReadCapabilityType capRead = CapabilityUtil.getCapability(nativeCapabilitiesList, ReadCapabilityType.class);
  assertNotNull("Missing read capability" ,capRead);
  assertEquals("Wrong caching-only setting in read capability", Boolean.TRUE, capRead.isCachingOnly());
  List<Object> effectiveCapabilities = ResourceTypeUtil.getEffectiveCapabilities(resource);
  for (Object capability : effectiveCapabilities) {
    System.out.println("Capability: "+CapabilityUtil.getCapabilityDisplayName(capability)+" : "+capability);
  }
}

lhsCachingOnly = this.isCachingOnly();
Boolean rhsCachingOnly;
rhsCachingOnly = that.isCachingOnly();
if (!strategy.equals(LocatorUtils.property(thisLocator, "cachingOnly", lhsCachingOnly), LocatorUtils.property(thatLocator, "cachingOnly", rhsCachingOnly), lhsCachingOnly, rhsCachingOnly)) {
  return false;
lhsReturnDefaultAttributesOption = this.isReturnDefaultAttributesOption();
Boolean rhsReturnDefaultAttributesOption;
rhsReturnDefaultAttributesOption = that.isReturnDefaultAttributesOption();
if (!strategy.equals(LocatorUtils.property(thisLocator, "returnDefaultAttributesOption", lhsReturnDefaultAttributesOption), LocatorUtils.property(thatLocator, "returnDefaultAttributesOption", rhsReturnDefaultAttributesOption), lhsReturnDefaultAttributesOption, rhsReturnDefaultAttributesOption)) {
  return false;

private void addBasicReadCapability() {
  // Still need to add "read" capability. This capability would be added during schema processing,
  // because it depends on schema options. But if there is no schema we need to add read capability
  // anyway. We do not want to end up with non-readable resource.
  Set<Class<? extends APIOperation>> supportedOperations = connIdConnectorFacade.getSupportedOperations();
  if (supportedOperations.contains(GetApiOp.class) || supportedOperations.contains(SearchApiOp.class)){
    ReadCapabilityType capRead = new ReadCapabilityType();
    capabilities.add(CAPABILITY_OBJECT_FACTORY.createRead(capRead));
  }
}

assertEquals("Wrong caching-only setting in read capability", Boolean.TRUE, capRead.isCachingOnly());

assertNull("Read capability is caching only", capRead.isCachingOnly());
assertTrue("Read capability is not 'return default'", capRead.isReturnDefaultAttributesOption());