public QName getTypeName() { ItemDefinition definition = getDefinition(); return definition != null ? definition.getTypeName() : null; }
@Override public <ID extends ItemDefinition> ID findItemDefinitionByType(@NotNull QName typeName, @NotNull Class<ID> definitionClass) { // TODO: check for multiple definition with the same type for (Definition definition : definitions) { if (definitionClass.isAssignableFrom(definition.getClass())) { @SuppressWarnings("unchecked") ID itemDef = (ID) definition; if (QNameUtil.match(typeName, itemDef.getTypeName())) { return itemDef; } } } return null; }
@NotNull @Override public <TD extends TypeDefinition> Collection<TD> findTypeDefinitionsByElementName(@NotNull QName name, @NotNull Class<TD> clazz) { return findItemDefinitionsByElementName(name, ItemDefinition.class).stream() .flatMap(itemDef -> findTypeDefinitionsByType(itemDef.getTypeName(), clazz).stream()) .collect(Collectors.toList()); }
public static <D extends ItemDefinition> Object convertToOutputValue(Long longValue, D outputDefinition, Protector protector) throws ExpressionEvaluationException, SchemaException { if (longValue == null) { return null; } QName outputType = outputDefinition.getTypeName(); if (outputType.equals(DOMUtil.XSD_INT)) { return longValue.intValue(); } else if (outputType.equals(DOMUtil.XSD_LONG)) { return longValue; } else { return convertToOutputValue(longValue.toString(), outputDefinition, protector); } }
/** * Answers the question: "If the receiver would get itemName without any other information, will it be able to * derive suitable typeName from it?" If not, we have to provide explicit type definition for serialization. * * By suitable we mean such that can be used to determine specific object type. */ public boolean hasImplicitTypeDefinition(@NotNull QName itemName, @NotNull QName typeName) { List<ItemDefinition> definitions = findItemDefinitionsByElementName(itemName, ItemDefinition.class); if (definitions.isEmpty() || definitions.size() > 1) { return false; } ItemDefinition definition = definitions.get(0); if (definition.isAbstract()) { return false; } // TODO other conditions? return definition.getTypeName().equals(typeName); }
@Override public <ID extends ItemDefinition> ComparisonResult compareDefinitions(@NotNull ID def1, @NotNull ID def2) throws SchemaException { if (QNameUtil.match(def1.getTypeName(), def2.getTypeName())) { return ComparisonResult.EQUAL; } Class<?> cls1 = determineClassForItemDefinition(def1); Class<?> cls2 = determineClassForItemDefinition(def2); if (cls1 == null || cls2 == null) { return ComparisonResult.NO_STATIC_CLASS; } boolean cls1AboveOrEqualCls2 = cls1.isAssignableFrom(cls2); boolean cls2AboveOrEqualCls1 = cls2.isAssignableFrom(cls1); if (cls1AboveOrEqualCls2 && cls2AboveOrEqualCls1) { return ComparisonResult.EQUAL; } else if (cls1AboveOrEqualCls2) { return ComparisonResult.SECOND_IS_CHILD; } else if (cls2AboveOrEqualCls1) { return ComparisonResult.FIRST_IS_CHILD; } else { return ComparisonResult.INCOMPATIBLE; } }
@Override public Class<?> determineClassForItemDefinition(ItemDefinition<?> itemDefinition) { if (itemDefinition instanceof PrismContainerDefinition) { Class<?> cls = ((PrismContainerDefinition) itemDefinition).getCompileTimeClass(); if (cls != null) { return cls; } } return determineClassForType(itemDefinition.getTypeName()); }
@NotNull MatchingRule getMatchingRuleFromRegistry(MatchingRuleRegistry matchingRuleRegistry, Item filterItem) { try { return matchingRuleRegistry.getMatchingRule(matchingRule, filterItem.getDefinition().getTypeName()); } catch (SchemaException ex){ throw new IllegalArgumentException(ex.getMessage(), ex); } }
private boolean isOperationResult(ItemDelta delta) throws SchemaException { ItemDefinition def = delta.getDefinition(); if (def == null) { throw new SchemaException("No definition in delta for item " + delta.getPath()); } return OperationResultType.COMPLEX_TYPE.equals(def.getTypeName()); }
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)); } }
@Override public boolean canBeDefinitionOf(I item) { if (item == null) { return false; } ItemDefinition<?> itemDefinition = item.getDefinition(); if (itemDefinition != null) { if (!QNameUtil.match(getTypeName(), itemDefinition.getTypeName())) { return false; } // TODO: compare entire definition? Probably not. return true; } return true; }
public static RExtItem.Key createKeyFromDefinition(ItemDefinition<?> definition) { String name = RUtil.qnameToString(definition.getName()); String type = RUtil.qnameToString(definition.getTypeName()); RItemKind kind = RItemKind.getTypeFromItemDefinitionClass(definition.getClass()); return new Key(name, type, kind); }
/** * Marshals a given prism item (object, container, reference, property). * * @param item Item to be marshaled. * @param itemName Name to give to the item in the marshaled form. Usually null (i.e. taken from the item itself). * @param itemDefinition Definition to be used when parsing. Usually null (i.e. taken from the item itself). * @param context Serialization context. * @return Marshaled item. */ @NotNull RootXNodeImpl marshalItemAsRoot(@NotNull Item<?, ?> item, QName itemName, ItemDefinition itemDefinition, SerializationContext context) throws SchemaException { @NotNull QName realItemName = itemName != null ? itemName : item.getElementName(); ItemDefinition realItemDefinition = itemDefinition != null ? itemDefinition : item.getDefinition(); XNodeImpl content = marshalItemContent(item, realItemDefinition, context); if (realItemDefinition != null) { addTypeDefinitionIfNeeded(realItemName, realItemDefinition.getTypeName(), content); } return new RootXNodeImpl(realItemName, content); }
public static void assertDefinitionTypeLoose(ItemDefinition definition, QName itemName, QName type, int minOccurs, int maxOccurs) { assertNotNull("No definition for "+itemName, definition); assertTrue("Wrong definition type for "+itemName+": expected: " + type + ", real: " + definition.getTypeName(), QNameUtil.match(type, definition.getTypeName())); assertEquals("Wrong definition minOccurs for "+itemName, minOccurs, definition.getMinOccurs()); assertEquals("Wrong definition maxOccurs for "+itemName, maxOccurs, definition.getMaxOccurs()); }
private RAnyValue extractAndCreateValue(ItemDefinition def, PrismPropertyValue propertyValue, boolean assignment) throws SchemaException { ValueType type = getValueType(def.getTypeName()); Object extractedValue = extractValue(propertyValue, type.getValueType()); return assignment ? type.createNewAExtValue(extractedValue) : type.createNewOExtValue(extractedValue); }
public static void assertDefinition(ItemDefinition definition, QName itemName, QName type, int minOccurs, int maxOccurs) { assertNotNull("No definition for "+itemName, definition); assertEquals("Wrong definition type for "+itemName, type, definition.getTypeName()); assertEquals("Wrong definition minOccurs for "+itemName, minOccurs, definition.getMinOccurs()); assertEquals("Wrong definition maxOccurs for "+itemName, maxOccurs, definition.getMaxOccurs()); }
public Referencable asReferencable() { if (referencable != null) { return referencable; } Itemable parent = getParent(); if (parent != null) { QName xsdType = parent.getDefinition().getTypeName(); Class clazz = getPrismContext().getSchemaRegistry().getCompileTimeClass(xsdType); if (clazz != null) { try { referencable = (Referencable) clazz.newInstance(); } catch (InstantiationException | IllegalAccessException e) { throw new SystemException("Couldn't create jaxb object instance of '" + clazz + "': " + e.getMessage(), e); } } referencable.setupReferenceValue(this); } // A hack, just to avoid crashes. TODO think about this! return new DefaultReferencableImpl(this); }
public static void assertEqualsFilter(ObjectFilter objectFilter, QName expectedFilterDef, QName expectedTypeName, ItemPath path) { assertTrue("Wrong filter class: " + objectFilter.getClass(), objectFilter instanceof EqualFilter); EqualFilter filter = (EqualFilter) objectFilter; //we don't have definition in all situation..this is almost OK..it will be computed dynamicaly if (filter.getDefinition() != null){ assertEquals("Wrong filter definition element name", expectedFilterDef, filter.getDefinition().getName()); assertEquals("Wrong filter definition type", expectedTypeName, filter.getDefinition().getTypeName()); } assertPathEquivalent("Wrong filter path", path, filter.getFullPath()); }
public static <T> PropertyDelta<T> narrowPropertyDelta(PropertyDelta<T> propertyDelta, PrismObject<ShadowType> currentShadow, QName overridingMatchingRuleQName, MatchingRuleRegistry matchingRuleRegistry) throws SchemaException { QName matchingRuleQName = overridingMatchingRuleQName; ItemDefinition propertyDef = propertyDelta.getDefinition(); if (matchingRuleQName == null && propertyDef instanceof RefinedAttributeDefinition) { matchingRuleQName = ((RefinedAttributeDefinition)propertyDef).getMatchingRuleQName(); } MatchingRule<T> matchingRule = null; if (matchingRuleQName != null && propertyDef != null) { matchingRule = matchingRuleRegistry.getMatchingRule(matchingRuleQName, propertyDef.getTypeName()); } LOGGER.trace("Narrowing attr def={}, matchingRule={} ({})", propertyDef, matchingRule, matchingRuleQName); PropertyDelta<T> filteredDelta = propertyDelta.narrow(currentShadow, matchingRule); if (LOGGER.isTraceEnabled() && (filteredDelta == null || !filteredDelta.equals(propertyDelta))) { LOGGER.trace("Narrowed delta: {}", filteredDelta==null?null:filteredDelta.debugDump()); } return filteredDelta; }
@Test public void testParseToXNode() throws Exception { displayTestTitle("testParseToXNode"); ItemDefinition sequenceDef = getPrismContext().getSchemaRegistry().findItemDefinitionByElementName(SchemaConstants.S_SEQUENCE); System.out.println("sequence.substitutionHead = " + sequenceDef.getSubstitutionHead()); System.out.println("sequence.heterogeneousListItem = " + sequenceDef.isHeterogeneousListItem()); ComplexTypeDefinition sequenceCtd = getPrismContext().getSchemaRegistry().findComplexTypeDefinitionByType(sequenceDef.getTypeName()); System.out.println("ExpressionSequenceType.list = " + sequenceCtd.isListMarker()); System.out.println("\n\n-----------------------------------\n"); String file = MiscUtil.readFile(getFile()); System.out.println("Original text:\n" + file); RootXNode xnode = getPrismContext().parserFor(file).parseToXNode(); System.out.println("XNode:\n" + xnode.debugDump()); System.out.println("source -> XNode -> JSON:\n" + getPrismContext().jsonSerializer().serialize(xnode)); System.out.println("source -> XNode -> YAML:\n" + getPrismContext().yamlSerializer().serialize(xnode)); System.out.println("source -> XNode -> XML:\n" + getPrismContext().xmlSerializer().serialize(xnode)); }