tessl/maven-org-apache-groovy--groovy-json
JSON library for the Apache Groovy programming language providing JSON parsing, generation, and manipulation capabilities
—
Pending
utilities.mddocs/
Utilities & Extensions
Utility classes for string escaping, performance optimization, and error handling in JSON processing workflows.
Capabilities
StringEscapeUtils
Utility class providing string escaping and unescaping methods for Java and JavaScript contexts.
/**
* Utility class for string escaping and unescaping operations
*/
public class StringEscapeUtils {
/** Default constructor */
public StringEscapeUtils();
/** Escape string for Java context */
public static String escapeJava(String str);
public static void escapeJava(Writer out, String str) throws IOException;
/** Escape string for JavaScript context */
public static String escapeJavaScript(String str);
public static void escapeJavaScript(Writer out, String str) throws IOException;
/** Unescape Java-escaped string */
public static String unescapeJava(String str);
public static void unescapeJava(Writer out, String str) throws IOException;
/** Unescape JavaScript-escaped string */
public static String unescapeJavaScript(String str);
public static void unescapeJavaScript(Writer out, String str) throws IOException;
}Usage Examples:
import groovy.json.StringEscapeUtils;
import java.io.StringWriter;
// Java string escaping
String original = "Hello \"World\"\nNew line\tTab";
String escaped = StringEscapeUtils.escapeJava(original);
// Result: "Hello \\\"World\\\"\\nNew line\\tTab"
String unescaped = StringEscapeUtils.unescapeJava(escaped);
// Result: "Hello \"World\"\nNew line\tTab"
// JavaScript string escaping
String jsString = "alert('Hello');\n<script>";
String jsEscaped = StringEscapeUtils.escapeJavaScript(jsString);
// Result: "alert(\\'Hello\\');\\n\\u003Cscript\\u003E"
// Stream-based escaping for large strings
StringWriter writer = new StringWriter();
StringEscapeUtils.escapeJava(writer, largeString);
String result = writer.toString();
// Common escaping scenarios
public class JsonStringProcessor {
public static String prepareForJson(String input) {
return StringEscapeUtils.escapeJavaScript(input);
}
public static String extractFromJson(String jsonString) {
return StringEscapeUtils.unescapeJavaScript(jsonString);
}
public static void writeEscapedToFile(String content, Writer fileWriter) throws IOException {
StringEscapeUtils.escapeJava(fileWriter, content);
}
}JsonException
Runtime exception class for JSON processing errors with comprehensive error information.
/**
* Runtime exception for JSON processing errors
*/
public class JsonException extends RuntimeException {
/** Default constructor */
public JsonException();
/** Constructor with error message */
public JsonException(String message);
/** Constructor with message and cause */
public JsonException(String message, Throwable cause);
/** Constructor with cause only */
public JsonException(Throwable cause);
}Usage Examples:
import groovy.json.JsonException;
import groovy.json.JsonSlurper;
// Basic exception handling
try {
JsonSlurper slurper = new JsonSlurper();
Object result = slurper.parseText("invalid json");
} catch (JsonException e) {
System.err.println("JSON parsing failed: " + e.getMessage());
e.printStackTrace();
}
// Custom exception throwing
public class JsonValidator {
public static void validateJsonStructure(String json) throws JsonException {
if (json == null || json.trim().isEmpty()) {
throw new JsonException("JSON input cannot be null or empty");
}
if (!json.trim().startsWith("{") && !json.trim().startsWith("[")) {
throw new JsonException("JSON must start with '{' or '['");
}
try {
new JsonSlurper().parseText(json);
} catch (Exception e) {
throw new JsonException("Invalid JSON structure", e);
}
}
}
// Exception wrapping for custom processing
try {
processComplexJsonOperation();
} catch (IOException e) {
throw new JsonException("I/O error during JSON processing", e);
} catch (IllegalArgumentException e) {
throw new JsonException("Invalid argument in JSON processing", e);
}FastStringService Interface
Performance optimization interface for efficient string operations in JSON processing.
/**
* Interface for optimized string operations
*/
public interface FastStringService {
/** Convert string to character array efficiently */
char[] toCharArray(String string);
/** Create string from character array without copying when possible */
String noCopyStringFromChars(char[] chars);
}FastStringServiceFactory Interface
Factory interface for creating FastStringService instances.
/**
* Factory interface for FastStringService instances
*/
public interface FastStringServiceFactory {
/** Get FastStringService instance */
FastStringService getService();
}DefaultFastStringService
Default implementation of FastStringService providing optimized string operations.
/**
* Default implementation of FastStringService
*/
public class DefaultFastStringService implements FastStringService {
/** Convert string to character array (implements FastStringService) */
public char[] toCharArray(String string);
/** Create string from character array without copying (implements FastStringService) */
public String noCopyStringFromChars(char[] chars);
}DefaultFastStringServiceFactory
Default factory implementation for creating FastStringService instances.
/**
* Default factory implementation for FastStringService
*/
public class DefaultFastStringServiceFactory implements FastStringServiceFactory {
/** Get DefaultFastStringService instance (implements FastStringServiceFactory) */
public FastStringService getService();
}Usage Examples:
import org.apache.groovy.json.FastStringService;
import org.apache.groovy.json.DefaultFastStringServiceFactory;
// High-performance string operations
FastStringServiceFactory factory = new DefaultFastStringServiceFactory();
FastStringService stringService = factory.getService();
// Efficient string to char array conversion
String jsonData = loadLargeJsonString();
char[] chars = stringService.toCharArray(jsonData);
// Process character array directly
processJsonChars(chars);
// Convert back to string efficiently
String processed = stringService.noCopyStringFromChars(chars);
// Custom JSON processor using FastStringService
public class HighPerformanceJsonProcessor {
private final FastStringService stringService;
public HighPerformanceJsonProcessor() {
this.stringService = new DefaultFastStringServiceFactory().getService();
}
public String processJsonString(String json) {
// Convert to char array for processing
char[] chars = stringService.toCharArray(json);
// Perform in-place modifications
for (int i = 0; i < chars.length; i++) {
if (chars[i] == '\t') chars[i] = ' '; // Replace tabs with spaces
}
// Convert back without unnecessary copying
return stringService.noCopyStringFromChars(chars);
}
}Advanced Utility Patterns
Comprehensive Error Handling Strategy
public class RobustJsonProcessor {
private static final Logger logger = LoggerFactory.getLogger(RobustJsonProcessor.class);
public static class JsonProcessingResult {
private final Object data;
private final List<String> warnings;
private final boolean success;
public JsonProcessingResult(Object data, List<String> warnings, boolean success) {
this.data = data;
this.warnings = warnings;
this.success = success;
}
// Getters
public Object getData() { return data; }
public List<String> getWarnings() { return warnings; }
public boolean isSuccess() { return success; }
}
public static JsonProcessingResult safeParseJson(String json) {
List<String> warnings = new ArrayList<>();
if (json == null) {
return new JsonProcessingResult(null,
Arrays.asList("Input JSON is null"), false);
}
if (json.trim().isEmpty()) {
return new JsonProcessingResult(null,
Arrays.asList("Input JSON is empty"), false);
}
try {
// Attempt to clean and fix common JSON issues
String cleanedJson = cleanJsonString(json, warnings);
JsonSlurper slurper = new JsonSlurper();
Object result = slurper.parseText(cleanedJson);
return new JsonProcessingResult(result, warnings, true);
} catch (JsonException e) {
logger.error("JSON parsing failed", e);
warnings.add("Parse error: " + e.getMessage());
return new JsonProcessingResult(null, warnings, false);
} catch (Exception e) {
logger.error("Unexpected error during JSON parsing", e);
warnings.add("Unexpected error: " + e.getMessage());
return new JsonProcessingResult(null, warnings, false);
}
}
private static String cleanJsonString(String json, List<String> warnings) {
String cleaned = json;
// Remove BOM if present
if (cleaned.startsWith("\uFEFF")) {
cleaned = cleaned.substring(1);
warnings.add("Removed BOM from JSON input");
}
// Fix common quote issues
if (cleaned.contains("'") && !cleaned.contains("\"")) {
cleaned = cleaned.replace("'", "\"");
warnings.add("Converted single quotes to double quotes");
}
return cleaned;
}
}Performance-Optimized String Processing
public class OptimizedStringProcessor {
private final FastStringService stringService;
private final char[] reusableBuffer;
private static final int BUFFER_SIZE = 8192;
public OptimizedStringProcessor() {
this.stringService = new DefaultFastStringServiceFactory().getService();
this.reusableBuffer = new char[BUFFER_SIZE];
}
public String processLargeJsonString(String json) {
char[] chars = stringService.toCharArray(json);
// In-place processing to avoid additional allocations
int writeIndex = 0;
boolean inString = false;
boolean escaped = false;
for (int i = 0; i < chars.length; i++) {
char c = chars[i];
if (!inString && Character.isWhitespace(c)) {
// Skip whitespace outside strings
continue;
}
if (c == '"' && !escaped) {
inString = !inString;
}
escaped = (c == '\\' && !escaped);
chars[writeIndex++] = c;
}
// Create new array with exact size needed
char[] result = new char[writeIndex];
System.arraycopy(chars, 0, result, 0, writeIndex);
return stringService.noCopyStringFromChars(result);
}
public List<String> extractStringLiterals(String json) {
List<String> literals = new ArrayList<>();
char[] chars = stringService.toCharArray(json);
StringBuilder current = new StringBuilder();
boolean inString = false;
boolean escaped = false;
for (char c : chars) {
if (c == '"' && !escaped) {
if (inString) {
literals.add(current.toString());
current.setLength(0);
}
inString = !inString;
} else if (inString) {
if (escaped || c != '\\') {
current.append(c);
}
}
escaped = (c == '\\' && !escaped);
}
return literals;
}
}Cross-Platform String Escaping
public class CrossPlatformEscaping {
public static String escapeForPlatform(String input, Platform platform) {
switch (platform) {
case JAVA:
return StringEscapeUtils.escapeJava(input);
case JAVASCRIPT:
return StringEscapeUtils.escapeJavaScript(input);
case JSON:
// Use JSON-specific escaping
return escapeJsonString(input);
default:
return input;
}
}
public static String unescapeFromPlatform(String input, Platform platform) {
switch (platform) {
case JAVA:
return StringEscapeUtils.unescapeJava(input);
case JAVASCRIPT:
return StringEscapeUtils.unescapeJavaScript(input);
case JSON:
return unescapeJsonString(input);
default:
return input;
}
}
private static String escapeJsonString(String input) {
StringBuilder sb = new StringBuilder();
for (int i = 0; i < input.length(); i++) {
char c = input.charAt(i);
switch (c) {
case '"':
sb.append("\\\"");
break;
case '\\':
sb.append("\\\\");
break;
case '\b':
sb.append("\\b");
break;
case '\f':
sb.append("\\f");
break;
case '\n':
sb.append("\\n");
break;
case '\r':
sb.append("\\r");
break;
case '\t':
sb.append("\\t");
break;
default:
if (c < 0x20 || c > 0x7E) {
sb.append(String.format("\\u%04x", (int) c));
} else {
sb.append(c);
}
break;
}
}
return sb.toString();
}
private static String unescapeJsonString(String input) {
// Implementation for JSON-specific unescaping
return JsonLexer.unescape(input);
}
public enum Platform {
JAVA, JAVASCRIPT, JSON
}
}Error Recovery and Debugging
JSON Debugging Utilities
public class JsonDebugUtils {
public static String prettyPrintWithLineNumbers(String json) {
String[] lines = JsonOutput.prettyPrint(json).split("\n");
StringBuilder sb = new StringBuilder();
for (int i = 0; i < lines.length; i++) {
sb.append(String.format("%3d: %s%n", i + 1, lines[i]));
}
return sb.toString();
}
public static List<String> validateJsonStructure(String json) {
List<String> issues = new ArrayList<>();
try {
JsonLexer lexer = new JsonLexer(new StringReader(json));
int braceDepth = 0;
int bracketDepth = 0;
while (lexer.hasNext()) {
JsonToken token = lexer.next();
switch (token.getType()) {
case OPEN_BRACE:
braceDepth++;
break;
case CLOSE_BRACE:
braceDepth--;
if (braceDepth < 0) {
issues.add("Unmatched closing brace at line " + token.getStartLine());
}
break;
case OPEN_BRACKET:
bracketDepth++;
break;
case CLOSE_BRACKET:
bracketDepth--;
if (bracketDepth < 0) {
issues.add("Unmatched closing bracket at line " + token.getStartLine());
}
break;
}
}
if (braceDepth > 0) {
issues.add("Unclosed braces: " + braceDepth);
}
if (bracketDepth > 0) {
issues.add("Unclosed brackets: " + bracketDepth);
}
} catch (Exception e) {
issues.add("Parse error: " + e.getMessage());
}
return issues;
}
}Install with Tessl CLI
npx tessl i tessl/maven-org-apache-groovy--groovy-json