Core Messages and Serialization

/**
 * Base interface for all protocol buffer message types
 */
public interface MessageLite extends MessageLiteOrBuilder {
    /** Serializes message to coded output stream */
    void writeTo(CodedOutputStream output) throws IOException;
    
    /** Returns the number of bytes required to encode this message */ 
    int getSerializedSize();
    
    /** Serializes message to ByteString */
    ByteString toByteString();
    
    /** Serializes message to byte array */
    byte[] toByteArray();
    
    /** Writes message to OutputStream */
    void writeTo(OutputStream output) throws IOException;
    
    /** Writes size-delimited message to OutputStream */
    boolean writeDelimitedTo(OutputStream output) throws IOException;
    
    /** Gets parser for messages of same type */
    Parser<? extends MessageLite> getParserForType();
    
    /** Gets default instance for this message type */
    MessageLite getDefaultInstanceForType();
    
    /** Creates new builder for this message type */
    Builder newBuilderForType();
    
    /** Creates builder initialized with this message's data */  
    Builder toBuilder();
    
    /** Interface for building MessageLite instances */
    public interface Builder extends MessageLiteOrBuilder, Cloneable {
        MessageLite build();
        MessageLite buildPartial();
        Builder clear();
        Builder clone();
        boolean isInitialized();
        
        Builder mergeFrom(CodedInputStream input) throws IOException;
        Builder mergeFrom(CodedInputStream input, ExtensionRegistryLite extensionRegistry) throws IOException;
        Builder mergeFrom(ByteString data) throws InvalidProtocolBufferException;
        Builder mergeFrom(ByteString data, ExtensionRegistryLite extensionRegistry) throws InvalidProtocolBufferException;
        Builder mergeFrom(byte[] data) throws InvalidProtocolBufferException;
        Builder mergeFrom(byte[] data, ExtensionRegistryLite extensionRegistry) throws InvalidProtocolBufferException;
        Builder mergeFrom(MessageLite other);
    }
}

/**
 * Extended interface for protocol buffer messages with reflection support
 */
public interface Message extends MessageLite, MessageOrBuilder {
    /** Gets parser for messages of same type (covariant return) */
    Parser<? extends Message> getParserForType();
    
    /** Creates new builder for this message type (covariant return) */
    Builder newBuilderForType();
    
    /** Creates builder initialized with this message's data (covariant return) */
    Builder toBuilder();
    
    /** Message equality comparison */
    boolean equals(Object other);
    
    /** Hash code computation */
    int hashCode();
    
    /** Protocol buffer text format representation */
    String toString();
    
    /** Interface for building Message instances with reflection support */
    public interface Builder extends MessageLite.Builder, MessageOrBuilder {
        Message build();
        Message buildPartial();
        Builder clear();
        Builder clone();
        
        Builder mergeFrom(Message other);
        Builder mergeFrom(CodedInputStream input) throws IOException; 
        Builder mergeFrom(CodedInputStream input, ExtensionRegistryLite extensionRegistry) throws IOException;
        
        // Field manipulation methods
        Builder setField(Descriptors.FieldDescriptor field, Object value);
        Builder addRepeatedField(Descriptors.FieldDescriptor field, Object value);
        Builder clearField(Descriptors.FieldDescriptor field);
        Builder clearOneof(Descriptors.OneofDescriptor oneof);
        
        // Nested message builders
        Message.Builder newBuilderForField(Descriptors.FieldDescriptor field);
        Message.Builder getFieldBuilder(Descriptors.FieldDescriptor field);
        Message.Builder getRepeatedFieldBuilder(Descriptors.FieldDescriptor field, int index);
    }
}

/**
 * Common interface for messages and builders providing field access
 */
public interface MessageOrBuilder extends MessageLiteOrBuilder {
    /** Get field value by descriptor */
    Object getField(Descriptors.FieldDescriptor field);
    
    /** Check if field is set */
    boolean hasField(Descriptors.FieldDescriptor field);
    
    /** Get repeated field count */
    int getRepeatedFieldCount(Descriptors.FieldDescriptor field);
    
    /** Get repeated field element by index */
    Object getRepeatedField(Descriptors.FieldDescriptor field, int index);
    
    /** Get all fields as map */
    Map<Descriptors.FieldDescriptor, Object> getAllFields();
    
    /** Check if oneof case is set */
    boolean hasOneof(Descriptors.OneofDescriptor oneof);
    
    /** Get active oneof field descriptor */
    Descriptors.FieldDescriptor getOneofFieldDescriptor(Descriptors.OneofDescriptor oneof);
    
    /** Get message descriptor */
    Descriptors.Descriptor getDescriptorForType();
    
    /** Get unknown fields */
    UnknownFieldSet getUnknownFields();
    
    /** Check if all required fields are set */
    boolean isInitialized();
    
    /** Find missing required fields */
    List<String> findInitializationErrors();
    
    /** Get initialization error string */
    String getInitializationErrorString();
}

/**
 * Partial implementation of Message interface providing common functionality
 */
public abstract class AbstractMessage implements Message {
    /** Check if all required fields are set */
    public boolean isInitialized();
    
    /** Find missing required fields */
    public List<String> findInitializationErrors();
    
    /** Get initialization error string */
    public String getInitializationErrorString();
    
    /** Check if oneof case is set */
    public boolean hasOneof(Descriptors.OneofDescriptor oneof);
    
    /** Get active oneof field descriptor */
    public Descriptors.FieldDescriptor getOneofFieldDescriptor(Descriptors.OneofDescriptor oneof);
    
    /** Generate text format string */
    public String toString();
    
    /** Write to coded output stream */
    public void writeTo(CodedOutputStream output) throws IOException;
    
    /** Get serialized size in bytes */
    public int getSerializedSize();
    
    /** Compare messages for equality */
    public boolean equals(Object other);
    
    /** Generate hash code */
    public int hashCode();
    
    /**
     * Abstract builder implementation for Message types
     */
    public abstract static class Builder<BuilderType extends Builder<BuilderType>>
            implements Message.Builder {
        /** Clone the builder */
        public BuilderType clone();
        
        /** Check if oneof case is set */
        public boolean hasOneof(Descriptors.OneofDescriptor oneof);
        
        /** Clear oneof field */
        public BuilderType clearOneof(Descriptors.OneofDescriptor oneof);
        
        /** Clear all fields */
        public BuilderType clear();
        
        /** Find missing required fields */
        public List<String> findInitializationErrors();
        
        /** Merge from another message */
        public BuilderType mergeFrom(Message other);
        
        /** Merge from coded input stream */
        public BuilderType mergeFrom(CodedInputStream input) throws IOException;
        
        /** Merge from coded input stream with extension registry */
        public BuilderType mergeFrom(CodedInputStream input, ExtensionRegistryLite extensionRegistry) throws IOException;
        
        /** Merge unknown fields */
        public BuilderType mergeUnknownFields(UnknownFieldSet unknownFields);
    }
}

/**
 * Partial implementation of MessageLite providing common serialization functionality
 */
public abstract class AbstractMessageLite implements MessageLite {
    /** Serialize to ByteString */
    public ByteString toByteString();
    
    /** Serialize to byte array */
    public byte[] toByteArray();
    
    /** Write to output stream */
    public void writeTo(OutputStream output) throws IOException;
    
    /** Write with length delimiter */
    public void writeDelimitedTo(OutputStream output) throws IOException;
    
    /**
     * Abstract builder implementation for MessageLite types
     */
    public abstract static class Builder<MessageType extends AbstractMessageLite, BuilderType extends Builder<MessageType, BuilderType>>
            implements MessageLite.Builder {
        /** Clone the builder */
        public abstract BuilderType clone();
        
        /** Merge from coded input stream */
        public BuilderType mergeFrom(CodedInputStream input) throws IOException;
        
        /** Merge from coded input stream with extension registry */
        public abstract BuilderType mergeFrom(CodedInputStream input, ExtensionRegistryLite extensionRegistry) throws IOException;
        
        /** Merge from ByteString */
        public BuilderType mergeFrom(ByteString data) throws InvalidProtocolBufferException;
        
        /** Merge from ByteString with extension registry */
        public BuilderType mergeFrom(ByteString data, ExtensionRegistryLite extensionRegistry) throws InvalidProtocolBufferException;
        
        /** Merge from byte array */
        public BuilderType mergeFrom(byte[] data) throws InvalidProtocolBufferException;
        
        /** Merge from byte array with extension registry */ 
        public BuilderType mergeFrom(byte[] data, ExtensionRegistryLite extensionRegistry) throws InvalidProtocolBufferException;
        
        /** Merge from input stream */
        public BuilderType mergeFrom(InputStream input) throws IOException;
        
        /** Merge delimited from input stream */
        public boolean mergeDelimitedFrom(InputStream input) throws IOException;
        
        /** Merge from another message */
        public BuilderType mergeFrom(MessageLite other);
    }
}

/**
 * Immutable wrapper around byte arrays for efficient operations
 */
public abstract class ByteString {
    /** Empty ByteString constant */
    public static final ByteString EMPTY;
    
    // Static factory methods
    /** Creates ByteString from byte array */
    public static ByteString copyFrom(byte[] bytes);
    
    /** Creates ByteString from byte array slice */
    public static ByteString copyFrom(byte[] bytes, int offset, int size);
    
    /** Creates ByteString from ByteBuffer */
    public static ByteString copyFrom(ByteBuffer bytes);
    
    /** Creates ByteString from UTF-8 encoded string */
    public static ByteString copyFromUtf8(String text);
    
    /** Reads all bytes from InputStream */
    public static ByteString readFrom(InputStream streamToDrain) throws IOException;
    
    // Instance methods
    /** Gets byte at specified index */
    public abstract byte byteAt(int index);
    
    /** Returns the number of bytes */
    public abstract int size();
    
    /** Checks if ByteString is empty */
    public boolean isEmpty();
    
    /** Creates substring from beginIndex to end */
    public ByteString substring(int beginIndex);
    
    /** Creates substring with explicit end index */
    public ByteString substring(int beginIndex, int endIndex);
    
    /** Checks if starts with prefix */
    public boolean startsWith(ByteString prefix);
    
    /** Checks if ends with suffix */
    public boolean endsWith(ByteString suffix);
    
    /** Concatenates with another ByteString */
    public ByteString concat(ByteString other);
    
    /** Converts to byte array (copies data) */
    public byte[] toByteArray();
    
    /** Decodes as UTF-8 string */
    public String toStringUtf8();
    
    /** Checks if contains valid UTF-8 */
    public boolean isValidUtf8();
    
    /** Creates CodedInputStream from this ByteString */
    public CodedInputStream newCodedInput();
    
    /** Creates InputStream from this ByteString */
    public InputStream newInput();
    
    /** Creates iterator over bytes */
    public ByteIterator iterator();
    
    /** Writes contents to OutputStream */
    public void writeTo(OutputStream out) throws IOException;
    
    /** Writes contents to ByteBuffer */
    public void copyTo(ByteBuffer target);
    
    /** Copies to byte array at offset */
    public void copyTo(byte[] target, int offset);
    
    /** Copies to byte array with source and target offsets */
    public void copyTo(byte[] target, int sourceOffset, int targetOffset, int numberToCopy);
    
    // Comparison and hashing
    public boolean equals(Object other);
    public int hashCode();
    public String toString();
}

import com.google.protobuf.ByteString;

// Creating ByteString instances
ByteString empty = ByteString.EMPTY;
ByteString fromBytes = ByteString.copyFrom(new byte[]{1, 2, 3, 4});
ByteString fromString = ByteString.copyFromUtf8("Hello Protocol Buffers");

// String-like operations
ByteString prefix = fromString.substring(0, 5); // "Hello"
ByteString suffix = fromString.substring(6);     // "Protocol Buffers"
ByteString combined = prefix.concat(ByteString.copyFromUtf8(" World"));

// Conversions
byte[] bytes = fromString.toByteArray();
String text = fromString.toStringUtf8();
boolean isValidUtf8 = fromString.isValidUtf8();

/**
 * Base class for generated protocol buffer message classes
 */
public abstract class GeneratedMessage extends AbstractMessage {
    /** Gets parser for message type (abstract method) */
    public abstract Parser<? extends GeneratedMessage> getParserForType();
    
    /** Testing configuration for field builders */
    public static void setAlwaysUseFieldBuildersForTesting(boolean useBuilders);
    
    /** Unknown fields storage */
    protected UnknownFieldSet unknownFields;
    
    /** Protected constructors */
    protected GeneratedMessage();
    protected GeneratedMessage(Builder<?> builder);
    
    /**
     * Base builder class for generated messages
     */
    public abstract static class Builder<BuilderType extends Builder<BuilderType>>
            extends AbstractMessage.Builder<BuilderType> {
        // Generated builders extend this class with type-safe field accessors
    }
}

/**
 * Base class for generated lite message classes (Android/constrained environments)
 */
public abstract class GeneratedMessageLite<MessageType extends GeneratedMessageLite<MessageType, BuilderType>, 
                                          BuilderType extends GeneratedMessageLite.Builder<MessageType, BuilderType>>
        extends AbstractMessageLite implements MessageLiteOrBuilder {
    
    /** Gets parser for message type */
    public final Parser<MessageType> getParserForType();
    
    /** Gets default instance */
    public final MessageType getDefaultInstanceForType();
    
    /** Creates new builder */
    public final BuilderType newBuilderForType();
    
    /** Creates builder from message */
    public final BuilderType toBuilder();
    
    /**
     * Base builder class for generated lite messages
     */
    public abstract static class Builder<MessageType extends GeneratedMessageLite<MessageType, BuilderType>,
                                        BuilderType extends Builder<MessageType, BuilderType>>
            extends AbstractMessageLite.Builder<MessageType, BuilderType>
            implements MessageLiteOrBuilder {
        // Generated lite builders extend this class
    }
}

/**
 * Implementation of Message that can represent arbitrary message types
 */
public final class DynamicMessage extends AbstractMessage {
    // Static factory methods
    /** Gets default instance for message type */
    public static DynamicMessage getDefaultInstance(Descriptors.Descriptor type);
    
    /** Creates builder for message type */
    public static Builder newBuilder(Descriptors.Descriptor type);
    
    // Parsing methods
    /** Parses from coded input stream */
    public static DynamicMessage parseFrom(Descriptors.Descriptor type, CodedInputStream input) 
        throws InvalidProtocolBufferException;
        
    /** Parses from coded input stream with extension registry */
    public static DynamicMessage parseFrom(Descriptors.Descriptor type, CodedInputStream input,
                                         ExtensionRegistryLite extensionRegistry) 
        throws InvalidProtocolBufferException;
        
    /** Parses from ByteString */
    public static DynamicMessage parseFrom(Descriptors.Descriptor type, ByteString data)
        throws InvalidProtocolBufferException;
        
    /** Parses from byte array */
    public static DynamicMessage parseFrom(Descriptors.Descriptor type, byte[] data)
        throws InvalidProtocolBufferException;
    
    /**
     * Builder for dynamic messages
     */
    public static final class Builder extends AbstractMessage.Builder<Builder> {
        /** Creates builder for message type */
        public static Builder newBuilder(Descriptors.Descriptor type);
        
        /** Builds the dynamic message */
        public DynamicMessage build();
        
        /** Builds partial dynamic message */
        public DynamicMessage buildPartial();
    }
}

import com.google.protobuf.*;

// Working with generated messages (example)
try {
    // Parsing messages
    MyMessage message = MyMessage.parseFrom(inputData);
    
    // Building messages
    MyMessage newMessage = MyMessage.newBuilder()
        .setStringField("value")
        .setIntField(42)
        .addRepeatedField("item1")
        .addRepeatedField("item2")
        .build();
        
    // Serialization
    ByteString serialized = newMessage.toByteString();
    byte[] bytes = newMessage.toByteArray();
    
} catch (InvalidProtocolBufferException e) {
    System.err.println("Parse error: " + e.getMessage());
}

// Working with dynamic messages
Descriptors.Descriptor messageType = getMessageDescriptor();
DynamicMessage dynamicMessage = DynamicMessage.newBuilder(messageType)
    .setField(fieldDescriptor1, "value")
    .setField(fieldDescriptor2, 123)
    .build();

/**
 * Exception thrown when protocol buffer parsing fails
 */
public class InvalidProtocolBufferException extends IOException {
    /** Creates with description */
    public InvalidProtocolBufferException(String description);
    
    /** Creates from exception */
    public InvalidProtocolBufferException(Exception e);
    
    /** Creates with description and cause */
    public InvalidProtocolBufferException(String description, Exception e);
    
    /** Attaches unfinished message for partial parsing recovery */
    public InvalidProtocolBufferException setUnfinishedMessage(MessageLite unfinishedMessage);
    
    /** Gets unfinished message if available */
    public MessageLite getUnfinishedMessage();
    
    /** Unwraps underlying IOException */
    public IOException unwrapIOException();
}

// Core lifecycle interfaces
public interface MessageLiteOrBuilder {}

public interface Parser<MessageType extends MessageLite> {
    MessageType parseFrom(CodedInputStream input) throws InvalidProtocolBufferException;
    MessageType parseFrom(ByteString data) throws InvalidProtocolBufferException;
    MessageType parseFrom(byte[] data) throws InvalidProtocolBufferException;
    MessageType parseFrom(InputStream input) throws IOException;
    MessageType parseDelimitedFrom(InputStream input) throws IOException;
}

// Lite extension support
public abstract class ExtensionLite<ContainingType extends MessageLite, Type> {
    // Extension field definition base class
}

public class ExtensionRegistryLite {
    public static ExtensionRegistryLite newInstance();
    public static ExtensionRegistryLite getEmptyRegistry();
}