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