Compiler Tag Trie Deserialization Framework
Find Innovative SolutionsGenerate Solutions
Solution Overview
Problem
Existing compilers, such as ASN.1 compilers, generate redundant boilerplate code for deserialization routines, increasing overhead due to the need for users to manually select and call appropriate deserialization routines for multiple messages, leading to thousands of additional lines of code.
Innovation Solution
A compiler-integrated intelligent deserialization framework that parses input data to build a tag trie, identifies tag paths associated with each message, and generates source code to deserialize messages efficiently, eliminating the need for redundant boilerplate code by directly converting input into an equivalent data structure representation.
Engineering Contradictions & Design Principles
Engineering Contradiction Analysis
1Adaptability or versatility
If existing compilers generate deserialization routines for multiple messages, then complete message handling capability is achieved, but redundant boilerplate code increases overhead
Solution Approach 1:
The patent combines multiple deserialization routines into a single unified routine that handles multiple message types. The compiler generates one deserialization routine that uses a tag trie data structure to automatically route to the appropriate message handler, eliminating the need for separate routines and reducing boilerplate code while maintaining complete message handling capability.
Solution Approach 2:
The unified deserialization routine performs multiple functions by handling different message types through a single entry point. The tag trie structure enables the routine to universally process various message formats by automatically identifying and routing to the correct handler, making one routine serve multiple purposes instead of requiring separate routines for each message type.
2Measurement precision
If users manually select and call appropriate deserialization routines, then precise message processing is achieved, but manual selection overhead increases complexity
Solution Approach 1:
The deserialization system performs self-service by automatically selecting the appropriate message handler through the tag trie structure. Instead of requiring users to manually identify and call the correct routine, the system autonomously routes messages based on their tag sequences, eliminating manual selection overhead while maintaining precise message processing.
Solution Approach 2:
The tag trie data structure serves as an intermediary between the incoming message and the deserialization handlers. It automatically matches message tags to the appropriate handler without user intervention, acting as a mediator that simplifies the interface while ensuring accurate message routing.
3Adaptability or versatility
If thousands of lines of boilerplate code are generated, then comprehensive message coverage is achieved, but code maintenance burden increases
Solution Approach 1:
The patent extracts the routing logic from numerous boilerplate code lines and consolidates it into the compact tag trie data structure. This separation removes the redundant routing code while preserving comprehensive message type coverage, significantly reducing maintenance burden while maintaining adaptability.
Solution Approach 2:
The system changes the parameter representation from extensive boilerplate code to a compact tag trie data structure with configurable parameters. This parameter transformation maintains comprehensive message coverage while reducing the codebase to a maintainable size, as the trie structure can be configured without writing extensive routing logic.
Data Source
AI summary
An example system includes a memory, a processor in communication with the memory, and a compiler that includes a serializer and a deserializer. The compiler executes on the processor to receive an input including a plurality of tags associated with a message. The compiler parses the input according to a specification and builds a tag trie from the plurality of tags, which includes a tag path and an end leaf. Each tag path includes a first tag and one or more candidate tags, which includes a last candidate tag. The last candidate tag in each tag path is the respective end leaf. The compiler walks the tag trie to obtain each tag path and generates a type of source code, which converts the input into an equivalent representation of a data structure associated with the message. The compiler also provides the type of source code to a user application.