1. import java.util.HashMap;
  2. import java.util.Map;
  3. import java.util.concurrent.ThreadLocalRandom;
  5. public class DataValidator {
  7. /**
  8. * Replaces values in a dataset with retry logic for validation checks.
  9. *
  10. * @param dataset The dataset to validate (represented as a Map).
  11. * @param validationFunction The function to apply for validation.
  12. * @param maxRetries The maximum number of retry attempts.
  13. * @return The modified dataset with potentially retried values.
  14. */
  15. public static Map<String, Object> validateWithRetry(Map<String, Object> dataset, ValidationFunction validationFunction, int maxRetries) {
  16. Map<String, Object> modifiedDataset = new HashMap<>(dataset); // Create a copy to avoid modifying the original
  18. for (Map.Entry<String, Object> entry : modifiedDataset.entrySet()) {
  19. String key = entry.getKey();
  20. Object value = entry.getValue();
  22. int retryCount = 0;
  23. boolean isValid = false;
  25. while (retryCount < maxRetries && !isValid) {
  26. try {
  27. if (validationFunction.validate(value)) {
  28. isValid = true;
  29. } else {
  30. retryCount++;
  31. // Simulate some delay or random modification if validation fails.
  32. if(retryCount > 1){
  33. value = modifyValue(value); //modify the value for further retry
  34. }
  35. }
  36. } catch (Exception e) {
  37. // Handle exceptions during validation (e.g., network errors).
  38. retryCount++;
  39. if(retryCount > 1){
  40. value = modifyValue(value);
  41. }
  42. // Log the error or handle appropriately.
  43. }
  44. }
  46. modifiedDataset.put(key, value); // Put back the value, even if not valid after max retries
  47. }
  49. return modifiedDataset;
  50. }
  52. /**
  53. * Simulates modifying a value for retry purposes. Can be customized.
  54. * @param value the value to modify
  55. * @return the modified value
  56. */
  57. private static Object modifyValue(Object value) {
  58. if (value instanceof Integer) {
  59. return ThreadLocalRandom.current().nextInt(0, 101); // Random integer between 0 and 100
  60. } else if (value instanceof String) {
  61. return "retry_" + value.toString();
  62. }
  63. return value; // Return original if type not handled
  64. }
  67. /**
  68. * Functional interface for validation logic.
  69. */
  70. public interface ValidationFunction {
  71. boolean validate(Object value);
  72. }
  76. public static void main(String[] args) {
  77. // Example Usage
  78. Map<String, Object> data = new HashMap<>();
  79. data.put("age", 30);
  80. data.put("email", "test@example.com");
  81. data.put("score", "abc"); //invalid score
  82. data.put("value",123);
  85. ValidationFunction ageValidator = value -> {
  86. if (value instanceof Integer) {
  87. return ((Integer) value) >= 0 && (Integer) value <= 120;
  88. }
  89. return false;
  90. };
  92. ValidationFunction emailValidator = value -> {
  93. if (value instanceof String) {
  94. return value.matches("^[\\w-\\.]+@([\\w-]+\\.)+[\\w-]{2,4}$");
  95. }
  96. return false;
  97. };
  99. Map<String, Object> validatedData = validateWithRetry(data, ageValidator, 3);
  100. System.out.println(validatedData);
  102. validatedData = validateWithRetry(data, emailValidator, 2);
  103. System.out.println(validatedData);
  104. }
  105. }

Add your comment