Unified Event Handling for In-Memory Models
Find Innovative SolutionsGenerate Solutions
Solution Overview
Problem
Current techniques for handling structured document formats like XML and JSON lack effective event handling mechanisms, particularly for detecting and managing changes to in-memory models, leading to cascading issues due to limited support for custom event handling and bulk updates.
Innovation Solution
A system that utilizes callbacks and custom event handlers to detect and handle changes across multiple models, allowing for flexible, scalable, and declarative event handling by annotating observable and observer elements, enabling unified change management across different file formats such as XML and JSON.
Engineering Contradictions & Design Principles
Engineering Contradiction Analysis
1Adaptability or versatility
If existing XML parsing techniques (DOM or SAX) are used, then parsing functionality is provided, but custom event handling and change detection capabilities are limited or non-existent
Solution Approach 1:
The patent introduces an intermediary event handling layer that sits between the XML/JSON parsing functionality and the application logic. This layer includes event handlers, observers, and callbacks that mediate change detection and notification, allowing custom event handling without modifying the core parsing mechanisms. The intermediary layer translates model changes into standardized events that can be handled uniformly across different file formats.
Solution Approach 2:
The patent creates a universal event handling framework that works across multiple file formats (XML, JSON) and model types. The same event handler infrastructure, observer patterns, and callback mechanisms can be applied to any in-memory model regardless of its source format, providing multi-functional capability. The framework unifies change detection, event notification, and bulk update handling across diverse data structures.
2Productivity
If manual change detection is implemented without automated event handling, then system complexity is reduced, but change detection efficiency and reliability deteriorate
Solution Approach 1:
The patent implements self-service change detection where the in-memory models automatically track their own changes through integrated event handlers and observers. The models serve themselves by detecting modifications to their structure and data, generating events, and notifying relevant callbacks without external intervention. This automated self-monitoring significantly improves change detection efficiency compared to manual approaches.
Solution Approach 2:
The patent establishes feedback loops where change events trigger notifications that can initiate further actions, validations, or cascading updates. The event handling system provides continuous feedback about model state changes to observers and callbacks, enabling reactive programming patterns. This feedback mechanism ensures reliable change detection and propagation throughout the system.
3Reliability
If bulk updates are performed without unified event handling, then update speed may improve, but consistency and reliability across multiple models deteriorate
Solution Approach 1:
The patent merges multiple event handling mechanisms (handlers, observers, callbacks) into a unified event management system that coordinates changes across multiple models. The framework combines individual model event streams into a coordinated bulk update process, ensuring that changes propagate consistently across related models. This unified approach maintains reliability by ensuring all models are updated in a consistent manner while providing a single point of control.
Data Source
AI summary
A computer system is provided that stores files in a structured file format and stores configuration files that indicate programmatic definitions for handlers. A processing system generates in-memory models of the structured files and creates a list of observer objects and observable objects. A handler is generated for each observer and observable object. The handlers handle how changes are to be updated and/or propagated to other files. When a data value of one of the files is to be updated and the data value is associated with an observable element of that file, the handler for the corresponding observable object is triggered. A handler for an observer object will also be triggered that shares the topic of the attribute being observed. Once the in-memory representation of the models are updated, the models are persisted back to non-volatile storage (as files) where the changes are reflected.