apache/fory

Features

• Language-Neutral Data Serialization - Converts complex data structures into a compact binary format for efficient exchange between different programming languages.
• High-Performance Binary Serialization - Provides high-performance conversion of complex object graphs into compact binary formats for minimal latency.
• Binary Deserialization - Reconstructs native language objects from binary streams based on a shared schema.
• Cross-Language Data Protocols - Provides standardized binary layouts to ensure data compatibility across different programming languages and hardware architectures.
• Schema Compatibility Validators - Matches local fields against remote metadata to ensure backward and forward compatibility during data evolution.
• Data Schema Management - Defines data structures using builders or decorators to create optimized serialization functions.
• Schema Versioning - Matches local fields against remote metadata identifiers to maintain forward and backward compatibility during schema evolution.
• Random Field Accesses - Reads individual data fields from a binary row without deserializing the entire record.
• IDL Model Generation - Produces compiler output for models and schema modules to define data structures used for serialization from IDL files.
• IDL Compilers - Transforms interface definition language files into type-safe native data models and serialization code.
• Zero-Copy Data Access - Enables reading specific data fields directly from binary buffers without reconstructing the entire object hierarchy.
• Schema-Based Code Generators - Compiles language-independent IDL schema definitions into native data structures and type-safe serialization helpers.
• Cross-Language Serialization Frameworks - Implements a system for converting object graphs into binary formats to ensure type-safe communication across different languages.
• Type Mapping - Translates schema expressions and wire tags into native data types to ensure consistent cross-language data exchange.
• Object Serialization - Encodes complex Java object graphs and primitive arrays into a compact binary format.
• Serializer Code Generators - Produces companion files from marked classes to automate the conversion between high-level objects and binary data.
• Reference Tracking - Tracks object identities during encoding to preserve shared references and resolve circular dependencies in complex object graphs.
• Schema Evolution Strategies - Maintains backward and forward compatibility of data models through an IDL-based schema evolution manager.
• Wire Format Interoperability - Implements a standardized binary layout and schema mapping to maintain data compatibility across different programming runtimes.
• Multi-Language Model Generators - Generates native data structures and type-safe models across multiple languages from a single shared contract.
• Columnar Data Processors - Implements a high-performance engine for processing and converting row-based serialized data into columnar layouts.
• Kotlin Type Serialization - Converts Kotlin data classes, unsigned primitives, and ranges into a compact binary format.
• Inheritance Management - Allows including fields from base classes into derived types to maintain structured data hierarchies.
• Polymorphic Type Serializers - Serializes objects based on their actual runtime types to support inheritance hierarchies.
• Analytics-Optimized Row Formats - Encodes data in a row format to enable high-throughput processing and zero-copy access for analytics.
• Collection Serialization - Encodes collections and maps with optimized headers for element type sharing and nullability.
• Temporal Data Converters - Serializes timestamps, dates, and durations using standardized epoch-based offsets and nanosecond adjustments.
• Zero-Copy Deserialization - Reads binary data directly from a buffer without allocating new memory for reconstructed objects.
• Native AOT Compilation - Generates native binaries using ahead-of-time compilation to reduce startup time and memory usage.
• Remote Procedure Call Frameworks - Generates type-safe service definitions and serialization helpers for low-latency communication between distributed services.
• Interoperability Modes - Enables switching between a portable wire mode for multi-language interoperability and a native mode for optimized performance.
• Whitelisted Deserialization - Protects against unauthorized code execution by restricting object instantiation to a set of registered trusted types during decoding.
• Decimal Arithmetic Types - Represents exact decimal values using a signed scale and unscaled integer to avoid binary floating-point precision errors.
• Deserialization Security - Protects against unauthorized type instantiation and recursive object attacks through whitelists and depth limiting.
• Enum Tagging Strategies - Implements configurable strategies for encoding enum constants using ordinals, numeric tags, or string names.
• Static Serialization Engines - Generates serializers via annotation processing to enable reflection-free, compact data exchange.
• Circular Reference Detection - Tracks object identities during serialization to handle circular dependencies and shared references.
• Dual-Mode Serialization - Allows toggling between a portable wire mode for interoperability and a native mode optimized for single-language performance.
• Deserialization Depth Limiting - Protects against recursive object attacks using depth limiting and type whitelists.
• Symmetric Language Optimizations - Uses a native serialization mode to leverage language-specific type systems when producers and consumers share a language.
• Serialization Hooks - Implements mechanisms for customizing serialization behavior, including object replacement and proxy handling.

Historial de estrellas