How to use

SInstance

in

org.opensingular.form

/**
 * Executa as inicilização de atribuição de valor da instância (ver {@link SType#withInitListener(IConsumer)}). Pode
 * sobrepor valores preexistentes.
 */
@SuppressWarnings({ "unchecked", "rawtypes" })
public final void init() {
  //Não deve chamar o init se estiver no modo de leitura do XML
  if (!getDocument().isRestoreMode()) {
    ((SType) getType()).init(() -> this);
  }
}

@Override
public String getReadOnlyFormattedText(WicketBuildContext ctx, IModel<? extends SInstance> model) {
  final SInstance mi = model.getObject();
  if (mi != null && mi.getValue() != null) {
    if (mi.asAtr().getDisplayString() != null) {
      return mi.toStringDisplay();
    }
    if (!(mi instanceof SIComposite)) {
      return String.valueOf(mi.getValue());
    }
    return mi.toString();
  }
  return StringUtils.EMPTY;
}

private void updateDocumentErrorsSingle(SInstance instance) {
  final SDocument document = instance.getDocument();
  final Integer id = instance.getId();
  final List<ValidationError> errors = contextErrors.get(id);
  document.setValidationErrors(id, errors);
}

  public void fromRelationalColumn(Object dbData, SInstance toInstance) {
    if (dbData == null) {
      toInstance.clearInstance();
    } else {
      toInstance.setValue(dbData.toString());
    }
  }
}

private void assertCorrectParentRelation(SInstance target) {
  for (SInstance child : target.getChildren()) {
    if (target != child.getParent()) {
      throw new AssertionError(
          "Incossitência Interna: A instância '" + child.getPathFull() + "', filho de '" +
              target.getPathFull() + "', aponta para um outro pai: '" + child.getParent() + "'");
    }
    assertCorrectParentRelation(child);
  }
}

private void assertCorrectDocumentReference(@Nonnull SInstance reference, @Nonnull SInstance target) {
  if (reference.getDocument() != target.getDocument()) {
    throw new AssertionError("Inconsitência Interna: O document da instancia '" + target.getPathFull() +
        "' não é o mesmo da instância '" + reference.getPathFull() + "'");
  }
  target.forEachChild(child -> assertCorrectDocumentReference(reference, child));
}

@Override
@Nonnull
protected SInstance createNewAttribute(@Nonnull AttrInternalRef ref) {
  SType<?> attributeType = AttributeValuesManagerForSType.getAttributeDefinedHierarchy(getOwner().getType(), ref);
  SInstance instanceAtr = attributeType.newInstance(getOwner().getDocument());
  instanceAtr.setAsAttribute(ref, getOwner());
  return instanceAtr;
}

@Nonnull
public static <A extends SType<?>> Optional<SInstance> findAncestor(SInstance node, Class<A> ancestorType) {
  for (SInstance parent = node.getParent(); parent != null; parent = parent.getParent()) {
    if (parent.getType().getClass().equals(ancestorType)) {
      return Optional.of(parent);
    }
  }
  return Optional.empty();
}

private SInstance internalLoadSInstance(FormKey key, RefType refType, SDocumentFactory documentFactory,
                    FormVersionEntity formVersionEntity) {
  final SInstance instance     = MformPersistenciaXML.fromXML(refType, formVersionEntity.getXml(), documentFactory);
  final IConsumer loadListener = instance.getAttributeValue(SPackageBasic.ATR_LOAD_LISTENER);
  loadCurrentXmlAnnotationOrEmpty(instance.getDocument(), formVersionEntity);
  instance.setAttributeValue(SPackageFormPersistence.ATR_FORM_KEY, key);
  if (loadListener != null) {
    loadListener.accept(instance);
  }
  return instance;
}

@SuppressWarnings("unchecked")
public String getLabel() {
  String label = instance.asAtr().getLabel();
  if (label == null) {
    label = SFormUtil.getTypeLabel((Class<? extends SType<?>>) instance.getType().getClass()).orElse(null);
  }
  if (label == null) {
    label = instance.getName();
  }
  return label;
}

  @Override
  public void onConfigure(Component component) {
    if (instanceModel.getObject() != null) {
      instanceModel.getObject().getDocument().updateAttributes(null);
    }
  }
}

private static void initSubFieldsIfNeeded(@Nonnull SInstance instance) {
  if (hasKeepNodePredicatedInAnyChildren(instance.getType())) {
    //Forces all sub fields in all sub composites to be created just by walking through then
    SInstances.streamDescendants(instance, true).forEach(si -> si.getId());
  }
}

private static void copyIdValues(SInstance source, SInstance target) {
  target.setId(source.getId());
  if (source instanceof SIComposite) {
    SIComposite sourceComposite = (SIComposite) source;
    SIComposite targetComposite = (SIComposite) target;
    for (int i = 0; i < sourceComposite.getFields().size() ; i++) {
      copyIdValues(sourceComposite.getField(i), targetComposite.getField(i));
    }
  } else if (source instanceof SIList) {
    SIList sourceList = (SIList) source;
    SIList targetList = (SIList) target;
    if (sourceList.getChildren() != null) {
      for (int i = 0; i < sourceList.getChildren().size() ; i++) {
        SInstance sourceItem = (SInstance) sourceList.getChildren().get(i);
        SInstance targetItem = (SInstance) targetList.getChildren().get(i);
        copyIdValues(sourceItem, targetItem);
      }
    }
  }
}

/**
 * Criar um XPath para a instância no formato "order[@id=1]/address[@id=4]/street[@id=5]".
 */
private StringBuilder buildXPath(SInstance instance, StringBuilder path) {
  if (instance.getParent() != null) {
    buildXPath(instance.getParent(), path);
  }
  if (path.length() != 0) {
    path.append('/');
  }
  path.append(instance.getName()).append("[@id=").append(instance.getId()).append(']');
  return path;
}

  @Override
  protected Set<String> update(Set<String> oldClasses) {
    if (model.getObject().getAttributeValue(SPackageBasic.ATR_DEPENDS_ON_FUNCTION) != null) {
      oldClasses.add("dependant-input-group");
    }
    return oldClasses;
  }
});

@Override
public I get() {
  if (instance == null && fs != null) {
    instance = (I) FormSerializationUtil.toInstance(fs);
    instance.attachEventCollector();
    /*esse chamada é necessária nesse ponto para atualizar os atributos de visibilidade após a deserialização uma
    * vez que estes não são persistenentes . Talvez a melhor alternativa seja persistir esses valores de atributos*/
    instance.getDocument().updateAttributes(instance.getEventCollector());
    fs = null;
  }
  return instance;
}

protected String createPetitionDescriptionFromForm(SInstance instance) {
  return instance.toStringDisplay();
}

private <ST extends SType<?>> SInstance resolveTypeFinderInstance(IFunction<T, ST> typeFinder) {
  SInstance instance = getRootSInstanceForGivenSTypeClass();
  ST        subtype  = typeFinder.apply((T) instance.getType());
  return instance.findNearest((SType<SInstance>) subtype).orElse(null);
}

public static SInstance tupleKeyRef(SInstance instance) {
  return findAncestor(instance, tableContext(instance.getType())).orElseThrow(() -> new SingularFormException(
      "Relational mapping should provide table name for an ancestor type of the instance '"
          + instance.getName() + "'."));
}

/**
 * Encontra a posição de um elemento dentro da lista com o ID informado. Retorna -1 senão encontrar.
 */
private static int findById(Integer instanceId, List<? extends SInstance> list) {
  for (int i = 0; i < list.size(); i++) {
    if (instanceId.equals(list.get(i).getId())) {
      return i;
    }
  }
  return -1;
}