JSON and Text Format

/**
 * JSON format conversion utilities
 */
public class JsonFormat {
    // Static factory methods
    /** Creates Printer with default configuration */
    public static Printer printer();
    
    /** Creates Parser with default configuration */
    public static Parser parser();
    
    /**
     * Converts protobuf messages to JSON format
     */
    public static class Printer {
        // Configuration methods
        /** Sets type registry for Any message resolution */
        public Printer usingTypeRegistry(TypeRegistry typeRegistry);
        
        /** Includes fields with default values in output */
        public Printer includingDefaultValueFields();
        
        /** Preserves original proto field names instead of JSON names */
        public Printer preservingProtoFieldNames();
        
        /** Omits insignificant whitespace for compact output */
        public Printer omittingInsignificantWhitespace();
        
        /** Prints enum values as integers instead of names */
        public Printer printingEnumsAsInts();
        
        /** Sorts map keys in output for deterministic results */
        public Printer sortingMapKeys();
        
        // Printing methods
        /** Prints message to JSON string */
        public String print(MessageOrBuilder message) throws InvalidProtocolBufferException;
        
        /** Appends JSON representation to Appendable */
        public void appendTo(Appendable json, MessageOrBuilder message) throws InvalidProtocolBufferException, IOException;
    }
    
    /**
     * Parses JSON format to protobuf messages
     */
    public static class Parser {
        // Configuration methods
        /** Sets type registry for Any message resolution */
        public Parser usingTypeRegistry(TypeRegistry typeRegistry);
        
        /** Ignores unknown fields instead of throwing exceptions */
        public Parser ignoringUnknownFields();
        
        /** Creates parser builder for advanced configuration */
        public static Builder newBuilder();
        
        // Parsing methods
        /** Merges JSON into message builder */
        public void merge(String json, Message.Builder builder) throws InvalidProtocolBufferException;
        
        /** Merges JSON from Readable into message builder */
        public void merge(Readable json, Message.Builder builder) throws InvalidProtocolBufferException, IOException;
        
        /**
         * Builder for configuring JSON parser
         */
        public static class Builder {
            /** Sets type registry for Any message resolution */
            public Builder usingTypeRegistry(TypeRegistry typeRegistry);
            
            /** Ignores unknown fields during parsing */
            public Builder ignoringUnknownFields();
            
            /** Builds configured parser */
            public Parser build();
        }
    }
}

/**
 * Text format parsing and printing support
 */
public class TextFormat {
    // Static convenience methods
    /** Generate short debug string (deprecated, use printer()) */
    @Deprecated
    public static String shortDebugString(MessageOrBuilder message);
    
    /** Get default printer instance */
    public static Printer printer();
    
    /** Get debug format printer with special escaping */
    public static Printer debugFormatPrinter();
    
    /** Get default parser */
    public static Parser getParser();
    
    /** Parse text format into message builder */
    public static void merge(Readable input, Message.Builder builder) throws IOException;
    
    /** Parse text format string into message builder */
    public static void merge(CharSequence input, Message.Builder builder) throws ParseException;
    
    // Utility methods
    /** Escape bytes for text format output */
    public static String escapeBytes(ByteString input);
    
    /** Escape byte array for text format output */
    public static String escapeBytes(byte[] input);
    
    /** Convert unsigned int to string */
    public static String unsignedToString(int value);
    
    /** Convert unsigned long to string */
    public static String unsignedToString(long value);
    
    /**
     * Converts protobuf messages to human-readable text format
     */
    public static class Printer {
        // Configuration methods
        /** Configure ASCII escaping for non-ASCII characters */
        public Printer escapingNonAscii(boolean escapeNonAscii);
        
        /** Set type registry for Any message resolution */
        public Printer usingTypeRegistry(TypeRegistry typeRegistry);
        
        /** Set extension registry for extension field resolution */
        public Printer usingExtensionRegistry(ExtensionRegistryLite extensionRegistry);
        
        /** Configure single-line output format */
        public Printer emittingSingleLine(boolean singleLine);
        
        // Printing methods
        /** Print message to appendable output */
        public void print(MessageOrBuilder message, Appendable output) throws IOException;
        
        /** Print unknown fields to appendable output */
        public void print(UnknownFieldSet fields, Appendable output) throws IOException;
        
        /** Print message to string */
        public String printToString(MessageOrBuilder message);
        
        /** Print unknown fields to string */
        public String printToString(UnknownFieldSet fields);
        
        /** Generate short debug string (single line) */
        public String shortDebugString(MessageOrBuilder message);
        
        /** Print individual field value to string */
        public String printFieldToString(FieldDescriptor field, Object value);
    }
    
    /**
     * Parses text format to protobuf messages
     */
    public static class Parser {
        // Static factory method
        /** Creates parser builder for configuration */
        public static Builder newBuilder();
        
        // Parsing methods
        /** Parse text format into message builder */
        public void merge(Readable input, Message.Builder builder) throws IOException;
        
        /** Parse text format into message builder with extension registry */
        public void merge(Readable input, ExtensionRegistryLite extensionRegistry, Message.Builder builder) throws IOException;
        
        /**
         * Builder for configuring text format parser
         */
        public static class Builder {
            /** Set type registry for Any message resolution */
            public Builder setTypeRegistry(TypeRegistry typeRegistry);
            
            /** Allow unknown fields during parsing */
            public Builder setAllowUnknownFields(boolean allowUnknownFields);
            
            /** Allow unknown extensions during parsing */
            public Builder setAllowUnknownExtensions(boolean allowUnknownExtensions);
            
            /** Set policy for handling duplicate singular fields */
            public Builder setSingularOverwritePolicy(SingularOverwritePolicy policy);
            
            /** Set recursion limit for nested messages */
            public Builder setRecursionLimit(int recursionLimit);
            
            /** Build configured parser */
            public Parser build();
        }
        
        /** Policy for handling duplicate singular field values */
        public enum SingularOverwritePolicy {
            /** Allow overwriting (default behavior) */
            ALLOW_SINGULAR_OVERWRITES,
            /** Forbid overwriting, throw exception */
            FORBID_SINGULAR_OVERWRITES
        }
    }
}

/**
 * Text format escaping and utility functions
 */
public class TextFormatEscaper {
    /** Escape text for protocol buffer text format */
    public static String escapeText(String input);
    
    /** Escape bytes as text for protocol buffer format */
    public static String escapeBytes(byte[] input);
    
    /** Unescape text from protocol buffer text format */
    public static String unescapeText(String input) throws InvalidEscapeSequenceException;
    
    /** Unescape bytes from protocol buffer text format */
    public static ByteString unescapeBytes(CharSequence input) throws InvalidEscapeSequenceException;
}

/**
 * Represents a location in parsed text format
 */
public class TextFormatParseLocation {
    /** Get line number (0-based) */
    public int getLine();
    
    /** Get column number (0-based) */
    public int getColumn();
    
    /** Create location */
    public static TextFormatParseLocation create(int line, int column);
}

/**
 * Tree structure containing parse location information
 */
public class TextFormatParseInfoTree {
    /** Get parse locations for a field */
    public List<TextFormatParseLocation> getLocations(FieldDescriptor field);
    
    /** Get parse location for a field index */
    public TextFormatParseLocation getLocation(FieldDescriptor field, int index);
    
    /** Get nested tree for a field */
    public TextFormatParseInfoTree getNestedTree(FieldDescriptor field, int index);
    
    /** Builder for constructing parse info trees */
    public static class Builder {
        /** Set location for field */
        public Builder setLocation(FieldDescriptor field, TextFormatParseLocation location);
        
        /** Set nested tree for field */
        public Builder setNestedTree(FieldDescriptor field, int index, TextFormatParseInfoTree nestedTree);
        
        /** Build parse info tree */
        public TextFormatParseInfoTree build();
    }
}

import com.google.protobuf.util.JsonFormat;
import com.google.protobuf.TextFormat;
import com.google.protobuf.TypeRegistry;

// JSON format conversion
try {
    // Convert message to JSON
    JsonFormat.Printer jsonPrinter = JsonFormat.printer()
        .includingDefaultValueFields()
        .preservingProtoFieldNames()
        .omittingInsignificantWhitespace();
        
    String json = jsonPrinter.print(myMessage);
    System.out.println("JSON: " + json);
    
    // Parse JSON back to message
    JsonFormat.Parser jsonParser = JsonFormat.parser()
        .ignoringUnknownFields();
        
    MyMessage.Builder builder = MyMessage.newBuilder();
    jsonParser.merge(json, builder);
    MyMessage parsedMessage = builder.build();
    
} catch (InvalidProtocolBufferException e) {
    System.err.println("JSON conversion error: " + e.getMessage());
}

// Text format conversion
try {
    // Convert message to text format
    TextFormat.Printer textPrinter = TextFormat.printer()
        .escapingNonAscii(true)
        .emittingSingleLine(false);
        
    String textFormat = textPrinter.printToString(myMessage);
    System.out.println("Text format:\n" + textFormat);
    
    // Parse text format back to message  
    TextFormat.Parser textParser = TextFormat.getParser();
    MyMessage.Builder textBuilder = MyMessage.newBuilder();
    textParser.merge(textFormat, textBuilder);
    MyMessage parsedFromText = textBuilder.build();
    
} catch (IOException e) {
    System.err.println("Text format error: " + e.getMessage());
}

// Working with Any messages and type registry
TypeRegistry typeRegistry = TypeRegistry.newBuilder()
    .add(MyMessage.getDescriptor())
    .add(AnotherMessage.getDescriptor())
    .build();

JsonFormat.Printer anyPrinter = JsonFormat.printer()
    .usingTypeRegistry(typeRegistry)
    .includingDefaultValueFields();

// This will properly resolve Any message types
String jsonWithAny = anyPrinter.print(messageContainingAny);

// JSON field name mapping
// Proto field names: user_name, email_address  
// JSON field names: userName, emailAddress (camelCase by default)

// Special JSON representations for well-known types:
// google.protobuf.Timestamp -> RFC 3339 string: "1972-01-01T10:00:20.021Z"
// google.protobuf.Duration -> Duration string: "1.000340012s", "1s"  
// google.protobuf.Struct -> JSON object: {"key": "value"}
// google.protobuf.Value -> JSON value: "string", 123, true, null, [], {}
// google.protobuf.ListValue -> JSON array: [1, 2, 3]
// google.protobuf.NullValue -> JSON null: null
// google.protobuf.Any -> JSON object: {"@type": "type.googleapis.com/MyMessage", "field": "value"}

// Enum handling:
// Default: enum names as strings: "ENUM_VALUE"
// With printingEnumsAsInts(): enum numbers: 123

// Field presence:
// Proto3: only non-default values included by default
// With includingDefaultValueFields(): all fields included
// Proto2: optional fields only included if explicitly set

// Map fields:
// Represented as JSON objects: {"key1": "value1", "key2": "value2"}
// With sortingMapKeys(): deterministic key ordering

// Repeated fields:  
// Represented as JSON arrays: ["item1", "item2", "item3"]

// Binary data (bytes fields):
// Base64-encoded strings: "SGVsbG8gV29ybGQ="

// Text format syntax examples:
// 
// message MyMessage {
//   string name = 1;
//   int32 age = 2;
//   repeated string items = 3;
//   MyNestedMessage nested = 4;
// }
//
// Text format representation:
// name: "John Doe"
// age: 30
// items: "item1"
// items: "item2"
// nested {
//   field: "value"
// }

// String escaping in text format:
// Regular strings: "Hello World"
// Escaped strings: "Hello \"World\""
// Raw strings: R"(Hello "World")"
// Bytes: "\x48\x65\x6c\x6c\x6f"

// Comments in text format:
// # This is a comment
// name: "value"  # End-of-line comment

// Extension syntax:
// [com.example.my_extension]: "value"
// [my_extension]: 123

// Any message syntax:
// [type.googleapis.com/MyMessage] {
//   field: "value"
// }

/**
 * Debug format utilities
 */
public class DebugFormat {
    /** Generate single-line debug string */
    public static String toString(MessageOrBuilder message);
    
    /** Generate multi-line debug string */
    public static String toStringMultiline(MessageOrBuilder message);
}

// Debug format output example:
// MyMessage{name="John", age=30, items=["a", "b"], nested=MyNested{field="value"}}

// JSON format exceptions
try {
    JsonFormat.printer().print(message);
} catch (InvalidProtocolBufferException e) {
    // Handle JSON conversion errors:
    // - Unresolvable Any types without type registry
    // - Invalid enum values
    // - Required field violations
}

// Text format exceptions  
try {
    TextFormat.getParser().merge(input, builder);
} catch (IOException e) {
    // Handle text parsing errors:
    // - Invalid syntax
    // - Unknown field names
    // - Type mismatches
    // - Malformed escape sequences
} catch (ParseException e) {
    // Handle text format parse errors
}

// Parse exception for text format
public class ParseException extends Exception {
    public ParseException(String message);
    public ParseException(String message, Throwable cause);
}

// Invalid escape sequence exception
public class InvalidEscapeSequenceException extends Exception {
    public InvalidEscapeSequenceException(String description);
}

// Escaper utility class
public class TextFormatEscaper {
    // Text escaping utilities for custom formatters
}

// Legacy debug format (deprecated)
public class LegacyUnredactedTextFormat {
    // Deprecated - use TextFormat.printer() instead
}