1. import java.util.HashMap;
  2. import java.util.Map;
  4. class LogValidator {
  6. /**
  7. * Maps log stream fields for validation checks.
  8. *
  9. * @param logStream The input log stream as a string.
  10. * @param fieldMapping A map defining the fields to be validated. Key is the field name, value is a validation function.
  11. * @return A map containing the validation results for each field. Returns an empty map if logStream is null or fieldMapping is empty.
  12. */
  13. public static Map<String, Boolean> validateLogStream(String logStream, Map<String, ValidationFunction> fieldMapping) {
  14. Map<String, Boolean> validationResults = new HashMap<>();
  16. if (logStream == null || fieldMapping == null || fieldMapping.isEmpty()) {
  17. return validationResults; // Return empty map if input is invalid
  18. }
  20. String[] lines = logStream.split("\\r?\\n"); // Split log stream into lines
  22. for (Map.Entry<String, ValidationFunction> entry : fieldMapping.entrySet()) {
  23. String fieldName = entry.getKey();
  24. ValidationFunction validationFunction = entry.getValue();
  25. validationResults.put(fieldName, validateField(lines, fieldName, validationFunction));
  26. }
  28. return validationResults;
  29. }
  31. /**
  32. * Validates a specific field in the log stream.
  33. *
  34. * @param lines The array of log lines.
  35. * @param fieldName The name of the field to validate.
  36. * @param validationFunction The validation function for the field.
  37. * @return True if validation passes, false otherwise.
  38. */
  39. private static boolean validateField(String[] lines, String fieldName, ValidationFunction validationFunction) {
  40. for (String line : lines) {
  41. if (line.contains(fieldName)) {
  42. try {
  43. return validationFunction.validate(line, fieldName);
  44. } catch (Exception e) {
  45. System.err.println("Error validating field " + fieldName + ": " + e.getMessage());
  46. return false; // Return false on error
  47. }
  48. }
  49. }
  50. return false; // Field not found in any line
  51. }
  54. /**
  55. * Functional interface for defining validation logic.
  56. */
  57. public interface ValidationFunction {
  58. boolean validate(String line, String fieldName);
  59. }
  65. public static void main(String[] args) {
  66. // Example usage
  67. String logStream = "Timestamp: 2023-10-27 10:00:00, User: John Doe, Message: Successful operation";
  69. Map<String, ValidationFunction> fieldMapping = new HashMap<>();
  70. fieldMapping.put("Timestamp", TimestampValidator.validateTimestamp);
  71. fieldMapping.put("User", UserValidator.validateUsername);
  72. fieldMapping.put("Message", MessageValidator.validateMessageLength);
  74. Map<String, Boolean> results = validateLogStream(logStream, fieldMapping);
  76. for (Map.Entry<String, Boolean> entry : results.entrySet()) {
  77. System.out.println(entry.getKey() + ": " + entry.getValue());
  78. }
  79. }
  83. //Example Validation Functions
  84. static class TimestampValidator implements ValidationFunction {
  85. @Override
  86. public boolean validate(String line, String fieldName) {
  87. return line.contains(fieldName) && line.substring(line.indexOf(fieldName) + fieldName.length()).matches("\\d{4}-\\d{2}-\\d{2} \\d{2}:\\d{2}:\\d{2}"); //Basic Timestamp check
  88. }
  89. }
  91. static class UserValidator implements ValidationFunction {
  92. @Override
  93. public boolean validate(String line, String fieldName) {
  94. return line.contains(fieldName) && line.substring(line.indexOf(fieldName) + fieldName.length()).matches("[a-zA-Z\\s]+"); //Basic username check
  95. }
  96. }
  98. static class MessageValidator implements ValidationFunction {
  99. @Override
  100. public boolean validate(String line, String fieldName) {
  101. return line.contains(fieldName) && line.substring(line.indexOf(fieldName) + fieldName.length()).length() <= 100; //Message length check
  102. }
  103. }
  104. }

Add your comment