square/wire
Wire
Wire es un generador de código multiplataforma e implementación de gRPC y Protocol Buffers. Transforma definiciones de esquemas en bindings de lenguaje nativo con seguridad de tipos para Kotlin, Swift y Java para asegurar un intercambio de datos consistente y comunicación entre sistemas distribuidos.
El proyecto proporciona herramientas especializadas para la gestión de esquemas de protocol buffer, incluyendo la capacidad de eliminar tipos no utilizados y filtrar campos por versión para reducir el tamaño final de los binarios. También maneja la gestión de espacios de nombres y permite la creación de manejadores de esquemas personalizados para ejecutar lógica definida por el usuario durante la fase de compilación.
El framework cubre una amplia gama de capacidades, incluyendo la generación de interfaces de servicio para llamadas a procedimientos remotos síncronas y asíncronas, el mapeo de tipos de esquema a primitivas de lenguaje nativo y la serialización de mensajes a JSON. También incluye soporte para generar mensajes parcelables y clientes mock para pruebas.
Features
- Schema-Based Code Generators - Transforms protocol buffer definitions into type-safe native source code for multiple target languages.
- Cross-Platform Language Bindings Generators - Transforms schema definitions into type-safe native language bindings for Kotlin, Swift, and Java.
- gRPC Service Generators - Automatically generates gRPC service code from protocol definitions during the build process.
- Mobile gRPC Clients - Generates type-safe gRPC network code for mobile platforms to communicate with backend servers.
- Remote Procedure Call Frameworks - Implements a gRPC framework to execute remote procedure calls between distributed systems.
- Type-Safe Remote Calls - Implements gRPC service interfaces for type-safe, automatic serialization between distributed systems.
- gRPC Service Interfaces - Generates typed service interfaces for gRPC to handle synchronous and asynchronous remote procedure calls.
- Native Type Mappings - Converts standardized schema types into native language primitives to ensure consistent data representation across platforms.
- Java Protobuf Generators - Produces type-safe Java code from Protobuf schemas to ensure consistent data exchange between services.
- Cross-Platform State Serialization - Ensures data is interpreted identically across different programming languages and platforms using protocol buffers.
- Type-Safe Code Generators - Transforms schema files into type-safe native source code for messages and services to eliminate serialization errors.
- Protobuf Code Generators - Generates language-specific source code directly from protocol buffer schema definitions.
- Protocol Buffer Implementations - Provides a full implementation of the Protocol Buffers serialization format and encoding/decoding logic.
- Multi-Language - Supports service development across multiple languages using a shared RPC protocol and type-safe interfaces.
- Typed Language Bindings - Generates type-safe native language bindings that map schema definitions to specific programming language interfaces.
- Schema-to-Native Type Mappings - Provides mapping of protocol buffer schema types to native language primitives like timestamps or nullable types.
- Protobuf Schema Lifecycle Management - Manages protobuf schemas by pruning unused types, managing namespaces, and filtering fields by version.
- Custom Schema Handlers - Allows the execution of user-defined logic during compilation for specialized code generation, validation, or logging.
- Schema Element Pruning - Removes unwanted types and fields from generated code via exclusion lists or reachability analysis to reduce binary size.
- Schema Namespace Management - Uses manifest configuration files to resolve module dependencies and organize imports across multiple schema files.
- Protobuf Schema Management - Provides tools for organizing and pruning protocol buffer definitions to manage dependencies and reduce binary size.
- Version-Based Filtering - Filters out obsolete fields from generated sources based on version ranges to maintain backward compatibility.
- Module Namespaces - Manages hierarchical naming systems for Swift modules to organize code and prevent identifier collisions.
- Dependency Pruning - Implements reachability analysis to prune unused types and fields from schemas to reduce the final binary size.
- Compiler Plugins - Provides a plugin architecture for the Protocol Buffers compiler to automate the generation of custom data structures.
- Schema Pruning - Filters schemas to a specific subset of root types and dependencies to reduce total source code size.
- Schema Version Filtering - Removes obsolete schema fields based on defined version ranges to maintain backward compatibility in generated sources.
- Data Structures - Lightweight protocol buffer implementation for Android and Java.
- Data Structures and Memory - Lightweight protocol buffers for Android and Java.
- Data Structures - Lightweight protocol buffer implementation.
- ProGuard Configurations - Provides protocol buffer configuration rules.
