How to use

isCachingOnly

method

in

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

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());
}
 

/**
 * 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());
}

/**
 * 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;
  }
}

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;
}

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;

@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);
  }
}

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());