How to use

isEmptyOfData

method

in

org.opensingular.form.SInstance

public boolean isNotEmptyOfData(){
  return  !isEmptyOfData();
}

  @Override
  protected void onConfigure() {
    setVisible(!model.getObject().isEmptyOfData());
  }
};

  @Override
  protected void onConfigure() {
    setVisible(!model.getObject().isEmptyOfData());
  }
};

@Override
public Serializable getObject() {
  SInstance instance = getSInstance();
  if (instance == null || instance.isEmptyOfData()) {
    return null;
  }
  Optional<SInstanceConverter> converter = resolver.apply(instance);
  if (converter.isPresent()) {
    return converter.get().toObject(instance);
  } else if (instance instanceof SIComposite) {
    throw new SingularFormException("Nenhum converter foi informado para o tipo " + instance.getName(), instance);
  }
  return (Serializable) instance.getValue();
}

  @Override
  public EnderecoEmpresaInternacional toObject(SIComposite ins) {
    final SInstance value = (SInstance) ins.getField(id.getNameSimple());
    if (!value.isEmptyOfData()) {
      final Integer idEmpresa  = Value.of(value, idEmpresaInternacional);
      final Integer sequencial = Value.of(value, sequencialEndereco);
      return SPackageVocabularioControlado.dominioService(ins).buscarEmpresaInternacional(idEmpresa.longValue(), sequencial.shortValue());
    }
    return null;
  }
})

@Override
public Serializable getObject() {
  SInstance instance = getMInstancia();
  if (instance.isEmptyOfData()) {
    return null;
  }
  Optional<SInstanceConverter> converter = resolver.apply(instance);
  if (converter.isPresent()) {
    return converter.get().toObject(instance);
  } else if (instance instanceof SIComposite) {
    throw new SingularFormException("Nenhum converter foi informado para o tipo " + instance.getName(), instance);
  }
  return (Serializable) instance.getValue();
}

public boolean shouldRender() {
  return instance.asAtr().isVisible()
      && instance.asAtr().isExists()
      && (renderIfEmpty || !instance.isEmptyOfData());
}

if (!model.getObject().isEmptyOfData()) {

@Override
public String getObject() {
  SInstance instance = instance();
  if (instance == null || instance.isEmptyOfData()) {
    return null;
  }
  if (!Value.dehydrate(instance).equals(lastValue)) {
    lastValue = Value.dehydrate(instance);
    final IFunction<Object, Object>                   idFunction = instance.asAtrProvider().getIdFunction();
    final SInstanceConverter<Serializable, SInstance> converter  = instance.asAtrProvider().getConverter();
    if (idFunction != null && converter != null && !instance.isEmptyOfData()) {
      final Serializable converted = converter.toObject(instance);
      if (converted != null) {
        lastId = String.valueOf(idFunction.apply(converted));
      }
    }
  }
  return lastId;
}

@Override
@SuppressWarnings("rawtypes")
public Component appendInput(WicketBuildContext ctx, BSControls formGroup, IModel<String> labelModel) {
  final IModel<? extends SInstance> model = ctx.getModel();
  final List<Serializable> opcoesValue = new ArrayList<>();
  if (model.getObject().getType().isList()) {
    final Provider provider = model.getObject().asAtrProvider().getProvider();
    if (provider != null) {
      opcoesValue.addAll(provider.load(ProviderContext.of(ctx.getCurrentInstance())));
    }
  }
  //Dangling values
  if (!model.getObject().isEmptyOfData()) {
    final SIList list = (SIList) model.getObject();
    for (int i = 0; i < list.size(); i += 1) {
      SInstance ins = list.get(i);
      final SInstanceConverter converter = list.asAtrProvider().getConverter();
      final Serializable converterted = converter.toObject(ins);
      if (!opcoesValue.contains(converterted)) {
        opcoesValue.add(i, converterted);
      }
    }
  }
  return formGroupAppender(formGroup, model, opcoesValue);
}

@Override
public String getObject() {
  if (instance().isEmptyOfData()) {
    return null;
  }
  if (!Value.dehydrate(instance()).equals(lastValue)) {
    lastValue = Value.dehydrate(instance());
    final IFunction<Object, Object>                   idFunction = instance().asAtrProvider().getIdFunction();
    final SInstanceConverter<Serializable, SInstance> converter  = instance().asAtrProvider().getConverter();
    if (idFunction != null && converter != null && !instance().isEmptyOfData()) {
      final Serializable converted = converter.toObject(instance());
      if (converted != null) {
        lastId = String.valueOf(idFunction.apply(converted));
      }
    }
  }
  return lastId;
}

@SuppressWarnings("unchecked")
public List<Serializable> load(ProviderContext<?> providerContext) {
  final SInstance          instance = instanceISupplier.get();
  final Provider           provider = instance.asAtrProvider().getProvider();
  final List<Serializable> values   = new ArrayList<>();
  if (provider != null) {
    final List<Serializable> result = provider.load(providerContext);
    if (result != null) {
      values.addAll(result);
    }
    //Dangling values
    if (!instance.isEmptyOfData()) {
      final SInstanceConverter        converter  = instance.asAtrProvider().getConverter();
      final List<Object>              ids        = new ArrayList<>();
      final IFunction<Object, Object> idFunction = instance.asAtrProvider().getIdFunction();
    /*Collect All Ids*/
      values.forEach(v -> ids.add(idFunction.apply(v)));
      List<SInstance> selectedInstances = new ArrayList<>();
      if (instance instanceof SIList) {
        ((SIList<SInstance>) instance).forEach(selectedInstances::add);
      } else {
        selectedInstances.add(instance);
      }
      collectSelectedInstances(instance, values, converter, ids, idFunction, selectedInstances);
    }
  }
  return values;
}

@Override
public String getObject() {
  final SInstance mi = getSInstance();
  if (mi != null && mi.getValue() != null) {
    if (!mi.isEmptyOfData()) {
      if (mi.asAtr().getDisplayString() != null) {
        return mi.toStringDisplay();
      }
      if (!(mi instanceof SIComposite)) {
        return String.valueOf(mi.getValue());
      }
      return mi.toString();
    }
  }
  return null;
}

@Override
public String getObject() {
  final SInstance mi = getMInstancia();
  if (mi != null && mi.getValue() != null) {
    if (!mi.isEmptyOfData()) {
      if (mi.asAtr().getDisplayString() != null) {
        return mi.toStringDisplay();
      }
      if (!(mi instanceof SIComposite)) {
        return String.valueOf(mi.getValue());
      }
      return mi.toString();
    }
  }
  return null;
}

/**
 * rerun validation on types that are filled with data and currently valid and the invalid ones (filled or not)
 *
 * @param updatedInstances a list of instances to rerun the validation
 * @return
 */
private static void revalidateInvalidOrNonEmptyInstances(Iterable<SInstance> updatedInstances) {
  final InstanceValidationContext validationContext = new InstanceValidationContext();
  // limpa erros de instancias dependentes, e limpa o valor caso de este não seja válido para o provider
  for (SInstance it : updatedInstances) {
    //Executa validações que dependem do valor preenchido que não estão com valor vazio ou
    // que já haviam sido validadas anteriormente e possuem mensagens
    if (!it.isEmptyOfData() || it.hasValidationErrors()) {
      it.getDocument().clearValidationErrors(it.getId());
      validationContext.validateSingle(it);
    }
  }
}

private static void validate(Component component, AjaxRequestTarget target, SInstance fieldInstance) {
    if (!isSkipValidationOnRequest()) {
    final InstanceValidationContext validationContext;
    // Validação do valor do componente
    validationContext = new InstanceValidationContext();
    validationContext.validateSingle(fieldInstance);
    // limpa erros de instancias dependentes, e limpa o valor caso de este não seja válido para o provider
    for (SType<?> dependentType : fieldInstance.getType().getDependentTypes()) {
      fieldInstance
          .findNearest(dependentType)
          .ifPresent(it -> {
            it.getDocument().clearValidationErrors(it.getId());
            //Executa validações que dependem do valor preenchido
            if (!it.isEmptyOfData()) {
              validationContext.validateSingle(it);
            }
          });
    }
    WicketBuildContext
        .findNearest(component)
        .flatMap(ctx -> Optional.of(ctx.getRootContext()))
        .flatMap(ctx -> Optional.of(Stream.builder().add(ctx.getRootContainer()).add(ctx.getExternalContainer()).build()))
        .ifPresent(containers -> containers.forEach(container -> {
          updateValidationFeedbackOnDescendants(target, (MarkupContainer) container);
        }));
  }
}

  @Override
  public String getObject() {
    if (instance().isEmptyOfData()) {
      return null;
    } else if (!Value.dehydrate(instance()).equals(lastValue)) {
      lastValue = Value.dehydrate(instance());
      SInstanceConverter<Serializable, SInstance> converter = instance().asAtrProvider().getConverter();
      if (converter != null) {
        Serializable converted = converter.toObject(instance());
        if (converted != null) {
          lastDisplay = instance().asAtrProvider().getDisplayFunction().apply(converted);
        }
      }
    }
    return lastDisplay;
  }
});

  @Override
  public String getObject() {
    if (instance().isEmptyOfData()) {
      return null;
    } else if (!Value.dehydrate(instance()).equals(lastValue)) {
      lastValue = Value.dehydrate(instance());
      SInstanceConverter<Serializable, SInstance> converter = instance().asAtrProvider().getConverter();
      if (converter != null) {
        Serializable converted = converter.toObject(instance());
        if (converted != null) {
          lastDisplay = instance().asAtrProvider().getDisplayFunction().apply(converted);
        }
      }
    }
    return lastDisplay;
  }
});

@Override
public T toObject(SInstance ins) {
  if (!(ins instanceof SIComposite)) {
    throw new SingularFormException("AutoSICompositeConverter somente funciona com instancias compostas.", ins);
  }
  if (ins.isEmptyOfData()) {
    return null;
  }
  final SIComposite   cins          = (SIComposite) ins;
  final T             newInstance   = new Mirror().on(resultClass).invoke().constructor().withoutArgs();
  final SetterHandler setterHandler = new Mirror().on(newInstance).set();
  cins.getFields().forEach(f -> {
    final FieldSetter setter = setterHandler.field(f.getName());
    if (setter != null) {
      setter.withValue(f.getValue());
    }
  });
  return newInstance;
}

@Override
public T toObject(SInstance ins) {
  if (!(ins instanceof SIComposite)) {
    throw new SingularFormException("AutoSICompositeConverter somente funciona com instancias compostas.");
  }
  if (ins.isEmptyOfData()) {
    return null;
  }
  final SIComposite   cins          = (SIComposite) ins;
  final T             newInstance   = new Mirror().on(resultClass).invoke().constructor().withoutArgs();
  final SetterHandler setterHandler = new Mirror().on(newInstance).set();
  cins.getFields().forEach(f -> {
    final FieldSetter setter = setterHandler.field(f.getName());
    if (setter != null) {
      setter.withValue(f.getValue());
    }
  });
  return newInstance;
}