1. import java.util.HashMap;
  2. import java.util.Map;
  3. import java.util.regex.Matcher;
  4. import java.util.regex.Pattern;
  6. public class EntryValidator {
  8. /**
  9. * Validates a single entry based on predefined rules.
  10. * @param entry The entry to validate.
  11. * @param validationRules A map of field names to validation functions.
  12. * @return A map of error messages. Empty if no errors found.
  13. */
  14. public static Map<String, String> validateEntry(String entry, Map<String, ValidationFunction> validationRules) {
  15. Map<String, String> errors = new HashMap<>();
  17. for (Map.Entry<String, ValidationFunction> entryRule : validationRules.entrySet()) {
  18. String fieldName = entryRule.getKey();
  19. ValidationFunction validationFunction = entryRule.getValue();
  21. String fieldValue = getFieldValue(entry, fieldName); // Extract value for field
  23. if (validationFunction.validate(fieldValue)) {
  24. // Validation successful, no error
  25. } else {
  26. errors.put(fieldName, validationFunction.getErrorMessage());
  27. }
  28. }
  30. return errors;
  31. }
  34. /**
  35. * Extracts the value of a specific field from the entry string.
  36. * @param entry The entry string.
  37. * @param fieldName The name of the field.
  38. * @return The value of the field, or null if not found.
  39. */
  40. private static String getFieldValue(String entry, String fieldName) {
  41. String regex = "\\b" + fieldName + ":\\s*(.*?)(?:\\n|$)\\b"; //regex to extract field value
  42. Pattern pattern = Pattern.compile(regex);
  43. Matcher matcher = pattern.matcher(entry);
  44. if (matcher.find()) {
  45. return matcher.group(1).trim();
  46. }
  47. return null;
  48. }
  51. /**
  52. * Functional interface for validation functions.
  53. */
  54. @FunctionalInterface
  55. public interface ValidationFunction {
  56. boolean validate(String value);
  57. String getErrorMessage();
  58. }
  61. public static void main(String[] args) {
  62. // Example usage
  63. Map<String, ValidationFunction> rules = new HashMap<>();
  65. // Example rule: Name must be at least 3 characters
  66. rules.put("Name", value -> {
  67. if (value == null) return false;
  68. return value.length() >= 3;
  69. }, "Name must be at least 3 characters.");
  71. // Example rule: Email must be a valid email format
  72. rules.put("Email", value -> {
  73. if (value == null) return false;
  74. String emailRegex = "^[\\w-\\.]+@([\\w-]+\\.)+[\\w-]{2,4}$";
  75. Pattern pattern = Pattern.compile(emailRegex);
  76. return pattern.matcher(value).matches();
  77. }, "Invalid email format.");
  79. // Example rule: Age must be a number between 0 and 150
  80. rules.put("Age", value -> {
  81. if(value == null) return false;
  82. try {
  83. int age = Integer.parseInt(value);
  84. return age >= 0 && age <= 150;
  85. } catch (NumberFormatException e) {
  86. return false;
  87. }
  88. }, "Age must be a number between 0 and 150.");
  92. String entry1 = "Name: John Doe\nEmail: john.doe@example.com\nAge: 30";
  93. String entry2 = "Name: Jo\nEmail: invalid-email\nAge: 200";
  94. String entry3 = "Name: Jane\nEmail: jane@example.com\nAge: abc";
  97. System.out.println("Entry 1 Errors: " + validateEntry(entry1, rules));
  98. System.out.println("Entry 2 Errors: " + validateEntry(entry2, rules));
  99. System.out.println("Entry 3 Errors: " + validateEntry(entry3, rules));
  100. }
  101. }

Add your comment