How to use org.kie.dmn.model.v1_1

/**
 * Utility method to ensure any QName references contained inside the ItemDefinitions have the namespace correctly valorized, also accordingly to the prefix.
 * (Even in the case of {@link XMLConstants.DEFAULT_NS_PREFIX} it will take the DMN model namespace for the no-prefix accordingly.)
 */
public void normalize() {
  for (ItemDefinition itemDefinition : this.getItemDefinition()) {
    processQNameURIs(itemDefinition);
  }
}

  @Override
  public String toString() {
    return getName();
  }
}

@Override
public String toString() {
  return getName();
}

@Override
public String getIdentifierString() {
  if( this instanceof TNamedElement && ((TNamedElement)this).getName() != null ) {
    return ((TNamedElement)this).getName();
  } else if( this instanceof TDMNElement && ((TDMNElement)this).getId() != null ) {
    return ((TDMNElement)this).getId();
  } else {
    return "[unnamed "+getClass().getSimpleName()+"]";
  }
}

@Override
public List<DecisionService> getDecisionService() {
  if ( decisionService == null ) {
    decisionService = new ArrayList<>();
    // as DMN1.1 xsd is broken to allow proper persistence of DecisionService, do fetch them from extensions.
    if ( getExtensionElements() != null ) {
      List<DecisionService> collectDS = getExtensionElements().getAny().stream()
                                .filter(DecisionServices.class::isInstance).map(DecisionServices.class::cast)
                                .flatMap(dss -> dss.getDecisionService().stream())
                                .collect(Collectors.toList());
      decisionService.addAll(collectDS);
    }
  }
  return this.decisionService;
}

private Definitions buildSimplifiedDefinitions(final String namespace, final String... decisions) {
  final Definitions def = new TDefinitions();
  def.setNamespace(namespace);
  for (final String d : decisions) {
    final Decision dec = new TDecision();
    dec.setName(d);
    def.getDrgElement().add(dec);
    def.addChildren(dec);
    dec.setParent(def);
  }
  return def;
}

private static List<ItemDefinition> getBaseListOfItemDefinitions(final int nameIndexFrom) {
  final List<ItemDefinition> itemDefinitions = new ArrayList<>();
  for (int i = nameIndexFrom; i < NUMBER_OF_BASE_ITEM_DEFINITIONS + nameIndexFrom; i++) {
    final ItemDefinition it = new TItemDefinition();
    it.setName(ITEM_DEFINITION_NAME_BASE + i);
    itemDefinitions.add(it);
  }
  return itemDefinitions;
}

/**
 * @since DMN v1.2
 */
@Override
public void setName(String value) {
  getAdditionalAttributes().put(NAME_QNAME, value);
}

/**
 * Align to DMN v1.2
 */
@Override
public FunctionKind getKind() {
  String kindValueOnV11 = this.getAdditionalAttributes().get(KIND_QNAME);
  if (kindValueOnV11 == null || kindValueOnV11.isEmpty()) {
    return FunctionKind.FEEL;
  } else {
    switch (kindValueOnV11) {
      case "F":
        return FunctionKind.FEEL;
      case "J":
        return FunctionKind.JAVA;
      case "P":
        return FunctionKind.PMML;
      default:
        return FunctionKind.FEEL;
    }
  }
}

@Override
public String toString() {
  return "Definitions{" +
      "name=" + getName() +
      ", _import=" + _import +
      ", itemDefinition=" + itemDefinition +
      ", drgElement=" + drgElement +
      ", decisionService=" + decisionService +
      ", artifact=" + artifact +
      ", elementCollection=" + elementCollection +
      ", businessContextElement=" + businessContextElement +
      ", expressionLanguage='" + expressionLanguage + '\'' +
      ", typeLanguage='" + typeLanguage + '\'' +
      ", namespace='" + namespace + '\'' +
      ", exporter='" + exporter + '\'' +
      ", exporterVersion='" + exporterVersion + '\'' +
      '}';
}

  @Override
  public String toString() {
    return new StringJoiner(", ")
        .add("name: " + getName())
        .add("typeRef: " + typeRef)
        .add("allowedValues: " + allowedValues)
        .add("itemComponent: " + itemComponent)
        .add("typeLanguage: " + typeLanguage)
        .add("isCollection: " + isCollection)
        .toString();
  }
}

private static void processQNameURIs(ItemDefinition iDef) {
  final QName typeRef = iDef.getTypeRef();
  if (typeRef != null && XMLConstants.NULL_NS_URI.equals(typeRef.getNamespaceURI())) {
    final String namespace = iDef.getNamespaceURI(typeRef.getPrefix());
    iDef.setTypeRef(new QName(namespace, typeRef.getLocalPart(), typeRef.getPrefix()));
  }
  for (ItemDefinition comp : iDef.getItemComponent()) {
    processQNameURIs(comp);
  }
}

private Import makeImport(final String namespace, final String name, final String modelName) {
  final Import i = new TImport();
  i.setNamespace(namespace);
  final Map<QName, String> addAttributes = new HashMap<>();
  if (name != null) {
    addAttributes.put(TImport.NAME_QNAME, name);
  }
  if (modelName != null) {
    addAttributes.put(TImport.MODELNAME_QNAME, modelName);
  }
  i.setAdditionalAttributes(addAttributes);
  return i;
}

private ItemDefinition build(final String name, final ItemDefinition... components) {
  final ItemDefinition res = new TItemDefinition();
  res.setName(name);
  for ( final ItemDefinition ic : components ) {
    final ItemDefinition c = new TItemDefinition();
    c.setName("_" + name + "-" + ic.getName());
    c.setTypeRef(new QName(TEST_NS, ic.getName()));
    res.getItemComponent().add(c);
  }
  return res;
}

/**
 * @since DMN v1.2
 */
@Override
public String getName() {
  return getAdditionalAttributes().get(NAME_QNAME);
}

/**
 * Align to DMN v1.2
 */
@Override
public void setKind(FunctionKind value) {
  this.getAdditionalAttributes().put(KIND_QNAME, value.value());
}

private static ItemDefinition createItemDefinitionWithDeps(final ItemDefinition itemDefinitionTemplate,
                                 final List<ItemDefinition> dependencies,
                                 final int maxNumberOfDepsPerItemDefinition,
                                 final Set<String> usedNames) {
  // New ItemDefinition is created, so the original one stays untouched.
  final ItemDefinition it = new TItemDefinition();
  it.setName(itemDefinitionTemplate.getName());
  final List<ItemDefinition> possibleDependencies =
      dependencies.stream().filter(item -> !item.getName().equals(it.getName())).collect(Collectors.toList());
  addDepsToItemDefinition(it, possibleDependencies, maxNumberOfDepsPerItemDefinition, usedNames);
  return it;
}

private static void createAndAddDependency(final ItemDefinition itemDefinition, final ItemDefinition dependency) {
  final ItemDefinition newDependency = new TItemDefinition();
  newDependency.setName("_" + itemDefinition.getName() + "-" + dependency.getName());
  newDependency.setTypeRef(new QName(TEST_NS, dependency.getName()));
  itemDefinition.getItemComponent().add(newDependency);
}