com.vaadin.flow.data.binder.Result Java Examples

@Override
public Result<UUID> convertToModel(String value, ValueContext context) {
    if (value == null) {
        return Result.ok(null);
    }

    // Remove leading and trailing white space
    value = value.trim();

    // Parse string as UUID.
    UUID uuid = null;
    try {
        uuid = UUID.fromString(value);
    } catch (java.lang.IllegalArgumentException e) {
        LoggerFactory.getLogger(StringToUuidConverter.class.getName()).warn(
                "Unable to convert String to UUID: " + value, e);
        return Result.error(this.errorMessageProvider.apply(context));
    }
    return Result.ok(uuid); // Return the UUID object, converted from String.
}
 

/**
 * Convert the value to a Number using the given locale and
 * {@link #getFormat(Locale)}.
 *
 * @param value
 *            The value to convert
 * @param context
 *            The value context for conversion
 * @return The converted value
 */
protected Result<Number> convertToNumber(String value,
        ValueContext context) {
    if (value == null) {
        return Result.ok(null);
    }

    // Remove leading and trailing white space
    value = value.trim();

    // Parse and detect errors. If the full string was not used, it is
    // an error.
    ParsePosition parsePosition = new ParsePosition(0);
    Number parsedValue = getFormat(context.getLocale().orElse(null))
            .parse(value, parsePosition);
    if (parsePosition.getIndex() != value.length()) {
        return Result.error(getErrorMessage(context));
    }

    if (parsedValue == null) {
        // Convert "" to the empty value
        return Result.ok(emptyValue);
    }

    return Result.ok(parsedValue);
}
 

@Override
public Result<Date> convertToModel(String value, ValueContext context) {
    if (value == null) {
        return Result.ok(null);
    }

    // Remove leading and trailing white space
    value = value.trim();

    ParsePosition parsePosition = new ParsePosition(0);
    Date parsedValue = getFormat(context.getLocale().orElse(null))
            .parse(value, parsePosition);
    if (parsePosition.getIndex() != value.length()) {
        return Result.error("Could not convert '" + value);
    }

    return Result.ok(parsedValue);
}
 

@Override
public Result<Byte> convertToModel(String value, ValueContext context) {
    Result<Number> n = convertToNumber(value, context);
    return n.flatMap(number -> {
        if (number == null) {
            return Result.ok(null);
        } else {
            byte intValue = number.byteValue();
            if (intValue == number.longValue()) {
                // If the value of n is outside the range of long, the
                // return value of longValue() is either Long.MIN_VALUE or
                // Long.MAX_VALUE. The/ above comparison promotes int to
                // long and thus does not need to consider wrap-around.
                return Result.ok(intValue);
            } else {
                return Result.error(getErrorMessage(context));
            }
        }
    });
}
 

@Override
public Result<Integer> convertToModel(String value, ValueContext context) {
    Result<Number> n = convertToNumber(value, context);
    return n.flatMap(number -> {
        if (number == null) {
            return Result.ok(null);
        } else {
            int intValue = number.intValue();
            if (intValue == number.longValue()) {
                // If the value of n is outside the range of long, the
                // return value of longValue() is either Long.MIN_VALUE or
                // Long.MAX_VALUE. The/ above comparison promotes int to
                // long and thus does not need to consider wrap-around.
                return Result.ok(intValue);
            } else {
                return Result.error(getErrorMessage(context));
            }
        }
    });
}
 

@Override
public Result<Boolean> convertToModel(String value, ValueContext context) {
    if (value == null) {
        return Result.ok(null);
    }

    // Remove leading and trailing white space
    value = value.trim();

    Locale locale = context.getLocale().orElse(null);
    if (getTrueString(locale).equals(value)) {
        return Result.ok(true);
    } else if (getFalseString(locale).equals(value)) {
        return Result.ok(false);
    } else if (value.isEmpty()) {
        return Result.ok(null);
    } else {
        return Result.error(errorMessageProvider.apply(context));
    }
}
 

@Override
public Result<BigInteger> convertToModel(String value,
        ValueContext context) {
    return convertToNumber(value, context).map(number -> {
        if (number == null) {
            return null;
        }
        // Empty value will be a BigInteger
        if (number instanceof BigInteger) {
            return (BigInteger) number;
        }
        return ((BigDecimal) number).toBigInteger();
    });
}
 

@Override
public Result<java.sql.Date> convertToModel(Date value,
        ValueContext context) {
    if (value == null) {
        return Result.ok(null);
    }

    return Result.ok(new java.sql.Date(value.getTime()));
}
 

@Override
public Result<Double> convertToModel(String value, ValueContext context) {
    Result<Number> n = convertToNumber(value, context);

    return n.map(number -> {
        if (number == null) {
            return null;
        } else {
            return number.doubleValue();
        }
    });
}
 

@Override
public Result<Float> convertToModel(String value, ValueContext context) {
    Result<Number> n = convertToNumber(value, context);

    return n.map(number -> {
        if (number == null) {
            return null;
        } else {
            return number.floatValue();
        }
    });
}
 

@Override
public Result<Date> convertToModel(LocalDateTime localDate, ValueContext context) {
    if (localDate == null) {
        return Result.ok(null);
    }

    return Result.ok(Date.from(localDate.atZone(zoneId).toInstant()));
}
 

@Override
public Result<Long> convertToModel(String value, ValueContext context) {
    Result<Number> n = convertToNumber(value, context);
    return n.map(number -> {
        if (number == null) {
            return null;
        } else {
            return number.longValue();
        }
    });
}
 

@Override
public Result<Date> convertToModel(LocalDate localDate,
        ValueContext context) {
    if (localDate == null) {
        return Result.ok(null);
    }

    return Result.ok(Date.from(localDate.atStartOfDay(zoneId).toInstant()));
}
 

@Override
public Result<Integer> convertToModel(Double value, ValueContext context) {
    try {
        if (value == null) {
            return Result.ok(null);
        }
        return Result.ok(value.intValue());
    } catch (Exception ex) {
        return Result.error(errorMessage);
    }
}
 

@Override
public Result<Long> convertToModel(Date value, ValueContext context) {
    if (value == null) {
        return Result.ok(null);
    }

    return Result.ok(value.getTime());
}
 

@Override
public Result<Character> convertToModel(String value, ValueContext context) {
    if (value == null) {
        return Result.ok(null);
    }

    if (value.length() > 1) {
        return Result.error("Could not convert '" + value);
    }

    return Result.ok(value.charAt(0));
}
 

@Override
public Result<String> convertToModel(RadiusGroupDto value, ValueContext context) {
    if (value == null) {
        return Result.ok("");
    }
    radiusGroupDto = value;
    return Result.ok(value.getName());
}
 

@Override
public Result<String> convertToModel(T value, ValueContext context) {
    if (value == null) {
        return Result.ok("");
    }
    attributeDto = value;
    return Result.ok(value.getName());
}
 

@Override
public Result<String> convertToModel(RadiusUserDto value, ValueContext context) {
    if (value == null) {
        return Result.ok("");
    }
    radiusUserDto = value;
    return Result.ok(value.getUsername());
}
 

@Override
public Result<BigDecimal> convertToModel(String value,
        ValueContext context) {
    return convertToNumber(value, context)
            .map(number -> (BigDecimal) number);
}
 

/**
 * Constructs a converter from two functions. Any {@code Exception}
 * instances thrown from the {@code toModel} function are converted into
 * error-bearing {@code Result} objects using the given {@code onError}
 * function.
 *
 * @param <P>
 *            the presentation type
 * @param <M>
 *            the model type
 * @param toModel
 *            the function to convert to model
 * @param toPresentation
 *            the function to convert to presentation
 * @param onError
 *            the function to provide error messages
 * @return the new converter
 *
 * @see Result
 * @see Function
 */
static <P, M> Converter<P, M> from(SerializableFunction<P, M> toModel,
        SerializableFunction<M, P> toPresentation,
        SerializableFunction<Exception, String> onError) {

    return from(val -> Result.of(() -> toModel.apply(val), onError),
            toPresentation);
}
 

/**
 * Returns a converter that returns its input as-is in both directions.
 *
 * @param <T>
 *            the input and output type
 * @return an identity converter
 */
static <T> Converter<T, T> identity() {
    return from(t -> Result.ok(t), t -> t);
}
 

/**
 * Converts the given value from presentation type to model type.
 * <p>
 * A converter can optionally use locale to do the conversion.
 *
 * @param value
 *            The value to convert. Can be null
 * @param context
 *            The value context for the conversion.
 * @return The converted value compatible with the source type
 */
Result<MODEL> convertToModel(PRESENTATION value, ValueContext context);