How to use

MutableItemDefinition

in

com.evolveum.midpoint.prism

  mutableDef.setDisplayName(displayName);
  mutableDef.setDisplayOrder(displayOrder);
  mutableDef.setEmphasized(emphasized);
  mutableDef.setDeprecated(deprecated);
  mutableDef.setExperimental(experimental);
  if (limitationsType != null) {
    if (limitationsType.getMinOccurs() != null) {
      mutableDef.setMinOccurs(XsdTypeMapper.multiplicityToInteger(limitationsType.getMinOccurs()));
      mutableDef.setMaxOccurs(XsdTypeMapper.multiplicityToInteger(limitationsType.getMaxOccurs()));
      mutableDef.setProcessing(MiscSchemaUtil.toItemProcessing(limitationsType.getProcessing()));
        mutableDef.setCanAdd(accessType.isAdd());
        mutableDef.setCanModify(accessType.isModify());
        mutableDef.setCanRead(accessType.isRead());
if (valueEnumerationRef != null) {
  PrismReferenceValue valueEnumerationRVal = MiscSchemaUtil.objectReferenceTypeToReferenceValue(valueEnumerationRef, prismContext);
  mutableDef.setValueEnumerationRef(valueEnumerationRVal);

private void setMultiplicity(MutableItemDefinition itemDef, XSParticle particle, XSAnnotation annotation,
    boolean topLevel) {
  if (topLevel || particle == null) {
    itemDef.setMinOccurs(0);
    Element maxOccursAnnotation = SchemaProcessorUtil.getAnnotationElement(annotation, A_MAX_OCCURS);
    if (maxOccursAnnotation != null) {
      String maxOccursString = maxOccursAnnotation.getTextContent();
      int maxOccurs = XsdTypeMapper.multiplicityToInteger(maxOccursString);
      itemDef.setMaxOccurs(maxOccurs);
    } else {
      itemDef.setMaxOccurs(-1);
    }
  } else {
    // itemDef.setMinOccurs(particle.getMinOccurs());
    // itemDef.setMaxOccurs(particle.getMaxOccurs());
    itemDef.setMinOccurs(particle.getMinOccurs().intValue());
    itemDef.setMaxOccurs(particle.getMaxOccurs().intValue());
  }
}

  itemDef.setProcessing(ItemProcessing.IGNORE);
  itemDef.setProcessing(ItemProcessing.findByValue(processing.getTextContent()));
  itemDef.setDeprecated(deprecated);
  itemDef.setDeprecatedSince(deprecatedSince.getTextContent());
  itemDef.setExperimental(experimental);
  itemDef.setPlannedRemoval(plannedRemoval.getTextContent());
  itemDef.setElaborate(elaborate);
  itemDef.setOperational(operational);
  itemDef.setDisplayName(attributeDisplayName.getTextContent());
if (displayOrderElement != null) {
  Integer displayOrder = DOMUtil.getIntegerValue(displayOrderElement);
  itemDef.setDisplayOrder(displayOrder);
  itemDef.setHelp(help.getTextContent());
  itemDef.setEmphasized(emphasized);
  itemDef.setHeterogeneousListItem(heterogeneousListItem);

  outputDefinition.toMutable().setMaxOccurs(-1);
} else {
  outputDefinition.toMutable().setMaxOccurs(1);

if (attributeDefinition != null) {
  if (ignore == null || ignore.booleanValue()) {
    ((MutableItemDefinition) attributeDefinition).setProcessing(ItemProcessing.IGNORE);

@Test
public void testExtensionEnum() throws Exception {
  Session session = getFactory().openSession();
  QName valueName = new QName(NS_P, "enumType");
  ItemDefinition def = getDefinition(GenericObjectType.class, ItemPath.create(ObjectType.F_EXTENSION, valueName));
  AssertJUnit.assertNotNull(def);
  PrismProperty item = (PrismProperty) def.instantiate();
  item.setRealValue(BeforeAfterType.AFTER);
  def.toMutable().setName(valueName);
  RAnyConverter converter = new RAnyConverter(prismContext, extItemDictionary);
  Set<RAnyValue<?>> values;
  try {
    values = converter.convertToRValue(item, false, RObjectExtensionType.EXTENSION);
    AssertJUnit.fail("Should have throw serialization related exception after creating ext item");
  } catch (DtoTranslationException ex) {
    AssertJUnit.assertTrue(SerializationRelatedException.class.equals(ex.getCause().getClass()));
  }
  values = converter.convertToRValue(item, false, RObjectExtensionType.EXTENSION);
  AssertJUnit.assertEquals("Expected only one enum value, but was " + values.size(), 1, values.size());
  RAnyValue value = values.iterator().next();
  AssertJUnit.assertEquals("after", value.getValue());
  session.close();
}

private <T> List<PrismPropertyValue<T>> evaluateExpression(ScriptExpressionEvaluatorType scriptType, QName typeName, boolean scalar,
    ExpressionVariables variables, String shortDesc, OperationResult opResult) throws ExpressionEvaluationException, ObjectNotFoundException, SchemaException, CommunicationException, ConfigurationException, SecurityViolationException {
  MutableItemDefinition outputDefinition = PrismTestUtil.getPrismContext().definitionFactory().createPropertyDefinition(PROPERTY_NAME, typeName);
  if (!scalar) {
    outputDefinition.setMaxOccurs(-1);
  }
  return evaluateExpression(scriptType, outputDefinition, variables, shortDesc, opResult);
}

private void changeDefinition(QName piracyShip, QName piracyShipBroken) {
  PrismObjectDefinition<UserType> userDef = prismContext.getSchemaRegistry()
      .findObjectDefinitionByCompileTimeClass(UserType.class);
  PrismContainerDefinition<?> extensionDefinition = userDef.getExtensionDefinition();
  List<? extends ItemDefinition> extensionDefs = extensionDefinition.getComplexTypeDefinition().getDefinitions();
  for (ItemDefinition itemDefinition : extensionDefs) {
    if (itemDefinition.getName().equals(piracyShip)) {
      //iterator.remove();	// not possible as the collection is unmodifiable
      itemDefinition.toMutable().setName(piracyShipBroken);
    }
  }
}

if (returnTypeDef == null) {
  returnTypeDef = (D) prismContext.definitionFactory().createPropertyDefinition(SchemaConstantsGenerated.C_VALUE, returnType);
  returnTypeDef.toMutable().setMaxOccurs(functionToExecute.getReturnMultiplicity() != null && functionToExecute.getReturnMultiplicity() == ExpressionReturnMultiplicityType.SINGLE ? 1 : -1);

resultDef.setMaxOccurs(-1);

itemDefinition.toMutable().setMaxOccurs(-1);