Form implementation

To use validator you need to implement a interface named Form:

public interface Form {

    Optional<Integer> getInt(String key);

    Optional<Float> getFloat(String key);

    Optional<Double> getDouble(String key);

    Optional<Boolean> getBool(String key);

    Optional<Long> getLong(String key);

    Optional<String> getString(String key);

    Optional<Part> getPart(String key);

    boolean exist(String collection, String field, String value);
}

This is an example of class that implement Form for SparkJava:

public class SparkForm implements Form {

    private JSONObject json;
    private Request req;
    private boolean isJsonBody = false;

    public SparkForm(Request req, boolean isJsonBody) {
        this.req = req;
        this.isJsonBody = isJsonBody;
        this.json = new JSONObject(req.body());
    }

    public SparkForm(Request req) {
        this.req = req;
    }


    @Override
    public Optional<Integer> getInt(String key) {
        try {
            Optional<String> string = getString(key);
            return string.map(Integer::parseInt);
        } catch (Exception e) {
            return Optional.empty();
        }
    }

    @Override
    public Optional<Float> getFloat(String key) {
        try {
            Optional<String> string = getString(key);
            return string.map(Float::parseFloat);
        } catch (Exception e) {
            return Optional.empty();
        }
    }

    @Override
    public Optional<Double> getDouble(String key) {
        try {
            Optional<String> string = getString(key);
            return string.map(Double::parseDouble);
        } catch (Exception e) {
            return Optional.empty();
        }
    }

    @Override
    public Optional<Boolean> getBool(String key) {
        try {
            Optional<String> string = getString(key);
            if (string.isPresent())
            {
                String s = string.get();
                if (Arrays.asList("true", "false", "1", "0").contains(s))
                    return Optional.of(s.equals("true") || s.equals("1"));
            }
            return Optional.empty();
        } catch (Exception e) {
            return Optional.empty();
        }
    }

    @Override
    public Optional<String> getString(String key) {
        if (isJsonBody)
        {
            if (json.has(key))
                return Optional.of(json.getString(key));
            return Optional.empty();
        }
        return Optional.ofNullable(req.queryParams(key));
    }

    @Override
    public Optional<Long> getLong(String key) {
        try {
            Optional<String> string = getString(key);
            return string.map(Long::parseLong);
        } catch (Exception e) {
            return Optional.empty();
        }
    }

    @Override
    public Optional<Part> getPart(String key) {
        try {
            return Optional.ofNullable(req.raw().getPart(key));
        } catch (Exception e) {
            return Optional.empty();
        }
    }

    @Override
    public boolean exist(String collection, String field, String value) {
        // test class so i assume that collection is user and field email
        return RandomUser.randoms.stream().anyMatch(e -> e.email.equals(value));
    }
}

A simple implementation for HashMap:

public class HashMapForm implements Form {

    private Map<String, Object> map;

    public HashMapForm(Map<String, Object> map) {
        this.map = map;
    }


    @Override
    public Optional<Integer> getInt(String key) {
        try {
            Optional<String> string = getString(key);
            return string.map(Integer::parseInt);
        } catch (Exception e) {
            return Optional.empty();
        }
    }

    @Override
    public Optional<Float> getFloat(String key) {
        try {
            Optional<String> string = getString(key);
            return string.map(Float::parseFloat);
        } catch (Exception e) {
            return Optional.empty();
        }
    }

    @Override
    public Optional<Double> getDouble(String key) {
        try {
            Optional<String> string = getString(key);
            return string.map(Double::parseDouble);
        } catch (Exception e) {
            return Optional.empty();
        }
    }

    @Override
    public Optional<Boolean> getBool(String key) {
        try {
            Optional<String> string = getString(key);
            if (string.isPresent())
            {
                String s = string.get();
                if (Arrays.asList("true", "false", "1", "0").contains(s))
                    return Optional.of(s.equals("true") || s.equals("1"));
            }
            return Optional.empty();
        } catch (Exception e) {
            return Optional.empty();
        }
    }

    @Override
    public Optional<String> getString(String key) {
        Object o = map.get(key);
        if (o != null)
            return Optional.of(o.toString());
        return Optional.empty();
    }

    @Override
    public Optional<Long> getLong(String key) {
        try {
            Optional<String> string = getString(key);
            return string.map(Long::parseLong);
        } catch (Exception e) {
            return Optional.empty();
        }
    }

    @Override
    public Optional<Part> getPart(String key) {
        return Optional.empty();
    }

    @Override
    public boolean exist(String collection, String field, String value) {
        // test class so i assume that collection is user and field email
        return RandomUser.randoms.stream().anyMatch(e -> e.email.equals(value));
    }
}