public boolean isFocusObject() { return sourceDefinition != null && sourceDefinition.getCompileTimeClass() != null && FocusType.class.isAssignableFrom(sourceDefinition.getCompileTimeClass()); }
@Override public Class<V> getCompileTimeClass() { if (getDefinition() != null) { return getDefinition().getCompileTimeClass(); } return null; }
@Override public Class<?> determineClassForItemDefinition(ItemDefinition<?> itemDefinition) { if (itemDefinition instanceof PrismContainerDefinition) { Class<?> cls = ((PrismContainerDefinition) itemDefinition).getCompileTimeClass(); if (cls != null) { return cls; } } return determineClassForType(itemDefinition.getTypeName()); }
@Override public void applyDefinition(PrismContainerDefinition<C> definition) throws SchemaException { checkMutability(); if (definition == null) { return; } this.compileTimeClass = definition.getCompileTimeClass(); super.applyDefinition(definition); }
@Override public Class<C> getCompileTimeClass() { if (this.compileTimeClass != null) { return compileTimeClass; } if (getDefinition() != null) { return getDefinition().getCompileTimeClass(); } return null; }
@NotNull public <ID extends ItemDefinition> List<ID> findItemDefinitionsByCompileTimeClass( @NotNull Class<?> compileTimeClass, @NotNull Class<ID> definitionClass) { List<ID> found = new ArrayList<>(); for (Definition def: definitions) { if (definitionClass.isAssignableFrom(def.getClass())) { if (def instanceof PrismContainerDefinition) { @SuppressWarnings("unchecked") ID contDef = (ID) def; if (compileTimeClass.equals(((PrismContainerDefinition) contDef).getCompileTimeClass())) { found.add(contDef); } } else if (def instanceof PrismPropertyDefinition) { if (compileTimeClass.equals(prismContext.getSchemaRegistry().determineClassForType(def.getTypeName()))) { @SuppressWarnings("unchecked") ID itemDef = (ID) def; found.add(itemDef); } } else { // skipping the definition (PRD is not supported yet) } } } return found; }
@Override public S_FilterEntryOrEmpty exists(Object... components) { if (existsRestriction != null) { throw new IllegalStateException("Exists within exists"); } if (components.length == 0) { throw new IllegalArgumentException("Empty path in exists() filter is not allowed."); } ItemPath existsPath = ItemPath.create(components); PrismContainerDefinition pcd = resolveItemPath(existsPath, PrismContainerDefinition.class); //noinspection unchecked Class<? extends Containerable> clazz = pcd.getCompileTimeClass(); if (clazz == null) { throw new IllegalArgumentException("Item path of '" + existsPath + "' in " + currentClass + " does not point to a valid prism container."); } return new R_Filter(queryBuilder, clazz, OrFilterImpl.createOr(), null, false, this, null, existsPath, null, null,null, null); }
private static <ID extends ItemDefinition> ID augmentWithClass(ID definition, Class<ID> definitionClass, SchemaRegistry schemaRegistry, Class<?> clazz) throws SchemaException { if (clazz == null) { return definition; } if (definition instanceof PrismContainerDefinition && clazz.equals(((PrismContainerDefinition) definition).getCompileTimeClass())) { return definition; } QName typeNameFromClass = schemaRegistry.determineTypeForClass(clazz); if (typeNameFromClass == null) { throw new SchemaException("Unknown class " + clazz.getName()); } if (definition != null && definition.getTypeName().equals(typeNameFromClass)) { return definition; } @SuppressWarnings("unchecked") List<ID> defFromClass = schemaRegistry.findItemDefinitionsByCompileTimeClass((Class) clazz, (Class) definitionClass); if (defFromClass.size() != 1) { return definition; } else { return schemaRegistry.selectMoreSpecific(definition, defFromClass.get(0)); } }
public boolean hasFocusOfType(QName focusType) { PrismContext prismContext = getModelContext().getPrismContext(); if (prismContext == null) { throw new IllegalStateException("No prismContext in model context"); } PrismContainerDefinition pcd = prismContext.getSchemaRegistry().findContainerDefinitionByType(focusType); if (pcd == null) { LOGGER.warn("Couldn't find definition for type " + focusType); return false; } Class expectedClass = pcd.getCompileTimeClass(); if (expectedClass == null) { LOGGER.warn("Couldn't find class for type " + focusType); return false; } return hasFocusOfType(expectedClass); }
@SuppressWarnings("unchecked") private <T> T doParseRealValue(Class<T> clazz, RootXNodeImpl root) throws IOException, SchemaException { if (clazz == null) { ItemInfo info = ItemInfo.determine(itemDefinition, root.getRootElementName(), itemName, null, root.getTypeQName(), typeName, null, ItemDefinition.class, context, prismContext.getSchemaRegistry()); if (info.getItemDefinition() instanceof PrismContainerDefinition) { clazz = ((PrismContainerDefinition) info.getItemDefinition()).getCompileTimeClass(); } if (clazz == null && info.getTypeName() != null) { clazz = (Class) prismContext.getSchemaRegistry().determineClassForType(info.getTypeName()); } } // although bean unmarshaller can process containerables as well, prism unmarshaller is better at it if (clazz != null && !Containerable.class.isAssignableFrom(clazz) && getBeanUnmarshaller().canProcess(clazz)) { return getBeanUnmarshaller().unmarshal(root, clazz, context); } else if (clazz != null && Objectable.class.isAssignableFrom(clazz)) { // we need to NOT strip off OID PrismObject object = (PrismObject) doParseItem(root, clazz); return (T) object.asObjectable(); } else { PrismValue prismValue = doParseItemValue(root, clazz); if (prismValue == null) { return null; } else { return prismValue.getRealValue(); } } }
@Test public void testAccountDefinition() { System.out.println("===[ testAccountDefinition ]==="); // GIVEN PrismContext prismContext = PrismTestUtil.getPrismContext(); SchemaRegistry schemaRegistry = prismContext.getSchemaRegistry(); // WHEN PrismObjectDefinition<ShadowType> accountDefinition = schemaRegistry.findObjectDefinitionByElementName( SchemaConstants.C_SHADOW); assertNotNull("No account definition", accountDefinition); System.out.println("Account definition:"); System.out.println(accountDefinition.debugDump()); PrismObjectDefinition<ShadowType> accountDefinitionByClass = schemaRegistry.findObjectDefinitionByCompileTimeClass(ShadowType.class); assertTrue("Different account def", accountDefinition == accountDefinitionByClass); assertEquals("Wrong compile-time class in account definition", ShadowType.class, accountDefinition.getCompileTimeClass()); PrismAsserts.assertPropertyDefinition(accountDefinition, ShadowType.F_NAME, PolyStringType.COMPLEX_TYPE, 0, 1); PrismAsserts.assertPropertyDefinition(accountDefinition, ShadowType.F_DESCRIPTION, DOMUtil.XSD_STRING, 0, 1); assertFalse("Account definition is marked as runtime", accountDefinition.isRuntimeSchema()); PrismContainerDefinition attributesContainer = accountDefinition.findContainerDefinition(ShadowType.F_ATTRIBUTES); PrismAsserts.assertDefinition(attributesContainer, ShadowType.F_ATTRIBUTES, ShadowAttributesType.COMPLEX_TYPE, 0, 1); assertTrue("Attributes is NOT runtime", attributesContainer.isRuntimeSchema()); assertEquals("Wrong attributes compile-time class", ShadowAttributesType.class, attributesContainer.getCompileTimeClass()); }
assertTrue("<connectorConfiguration> is NOT dynamic", connectorConfContainerDef.isDynamic()); assertEquals("Wrong compile-time class for <connectorConfiguration> in resource definition", ConnectorConfigurationType.class, connectorConfContainerDef.getCompileTimeClass()); assertEquals("Wrong compile-time class for <schema> in resource definition", XmlSchemaType.class, schemaContainerDef.getCompileTimeClass()); assertEquals("Unexpected number of definitions in <schema>", 3, schemaContainerDef.getDefinitions().size()); PrismAsserts.assertPropertyDefinition(schemaContainerDef, XmlSchemaType.F_CACHING_METADATA,
PrismAsserts.assertDefinition(assignmentContainer, USER_ASSIGNMENT_QNAME, ASSIGNMENT_TYPE_QNAME, 0, -1); assertFalse("Assignment is runtime", assignmentContainer.isRuntimeSchema()); assertEquals("Wrong compile time class for assignment container", AssignmentType.class, assignmentContainer.getCompileTimeClass()); assertEquals("Assignment size", 4, assignmentContainer.getDefinitions().size()); PrismAsserts.assertPropertyDefinition(assignmentContainer, USER_DESCRIPTION_QNAME, DOMUtil.XSD_STRING, 0, 1);