How to use

ObjectResolver

in

org.nuxeo.ecm.core.schema.types.resolver

@Override
public Object fetch() {
  return resolver.fetch(property.getValue());
}

@Override
public List<Class<?>> getManagedClasses() {
  return resolver.getManagedClasses();
}

@Override
public void setObject(Object object) {
  Object reference = resolver.getReference(object);
  property.setValue(reference);
}

for (Class<?> clazz : resolver.getManagedClasses()) {
  try {
    object = readEntity(clazz, clazz, jn);
  throw new MarshallingException("Unable to parse the property " + property.getXPath());
value = resolver.getReference(object);
if (value == null) {
  throw new MarshallingException("Property " + property.getXPath()
      + " value cannot be resolved by the matching resolver " + resolver.getName());

@Override
public boolean validate(Object context) {
  return resolver.validate(property.getValue(), context);
}

@Override
public Description getDescription() {
  Map<String, Serializable> parameters = Collections.unmodifiableMap(resolver.getParameters());
  return new Description(resolver.getName(), parameters);
}

pathTokens.add(Constraint.MESSAGES_KEY);
pathTokens.add("resolver");
pathTokens.add(resolver.getName());
if (suffixCase != null) {
  pathTokens.add(suffixCase);
  return String.format("%s cannot resolve reference %s", resolver.getName(), computedInvalidValue);

  @Override
  public String getErrorMessage(Object invalidValue, Locale locale) {
    return resolver.getConstraintErrorMessage(invalidValue, locale);
  }
}

@Override
public ObjectResolver getResolver(String type, Map<String, String> parameters) {
  Class<? extends ObjectResolver> resolverClass = resolvers.get(type);
  if (resolverClass == null) {
    return null;
  }
  ObjectResolver resolver = null;
  try {
    resolver = resolverClass.newInstance();
  } catch (InstantiationException | IllegalAccessException e) {
    log.warn(String.format("Unable to instanciate %s - missing public constructor with no param",
        resolverClass.getCanonicalName()));
    return null;
  }
  try {
    resolver.configure(parameters);
  } catch (IllegalArgumentException e) {
    log.info(String.format("Unable to configure %s with parameters %s", resolverClass.getCanonicalName(),
        parameters));
    return null;
  }
  return resolver;
}

@Override
public boolean validate(Object context) {
  return resolver.validate(doc.getPropertyValue(xpath), context);
}

@Override
public <T> T fetch(Class<T> type) {
  return resolver.fetch(type, doc.getPropertyValue(xpath));
}

@Override
public boolean validate() {
  return resolver.validate(property.getValue());
}

@Override
public void setObject(Object object) {
  Serializable reference = resolver.getReference(object);
  doc.setPropertyValue(xpath, reference);
}

@Override
public List<Class<?>> getManagedClasses() {
  return resolver.getManagedClasses();
}

@Override
public Object fetch(Object context) {
  return resolver.fetch(doc.getPropertyValue(xpath), context);
}

@Override
public boolean validate() {
  return resolver.validate(doc.getPropertyValue(xpath), doc.getCoreSession());
}

@Override
public <T> T fetch(Class<T> type) {
  return resolver.fetch(type, property.getValue());
}

/**
 * Validates some value references an existing entity, in the given context
 *
 * @param value The reference.
 * @param context A resolver-specific context allowing resolution of the value.
 * @return true if value could be resolved as an existing external reference, false otherwise.
 * @throws IllegalStateException If this resolver has not been configured.
 * @since 10.2
 */
default boolean validate(Object value, Object context) {
  return validate(value);
}

@Override
public Object fetch(Object context) {
  return resolver.fetch(property.getValue(), context);
}

@Override
public boolean validate(Object object) {
  if (object == null) {
    return true;
  }
  return resolver.validate(object);
}