Browse Prior Art Database

Extensible parent/child markup processing using modular code registration and invocation.

IP.com Disclosure Number: IPCOM000125079D
Original Publication Date: 2005-May-18
Included in the Prior Art Database: 2005-May-18
Document File: 3 page(s) / 31K

Publishing Venue

IBM

Abstract

A method is described for extending the types of child nodes in a hierarchical markup language such as XML that can be parsed / handled using modular code extensions to an application runtime environment.

This text was extracted from a PDF file.
At least one non-text object (such as an image or picture) has been suppressed.
This is the abbreviated version, containing approximately 52% of the total text.

Page 1 of 3

Extensible parent/child markup processing using modular code registration and invocation.

Disclosed is a method for extending the types of child nodes that can be parsed / handled in a hierarchical markup language such as XML using modular code extensions to an application runtime environment.

In many software systems, it is valuable to be able to extend and modify the behavior of the system via the addition/removal of software modules or subcomponents through well defined interfaces. Examples of this include Java Enterprise Edition (tm) servers which allow the modular addition of Java Servlet(tm) and Enterprise Java Bean (tm) components to the server to change behavior of the server. On the client, an example of a modular platform is the open source Eclipse framework which is based on a platform which is a reference implementation of version 4 proposals of the Open Services Gateway Initiative (OSGi) standard.. The eclipse runtime platform executes as an aggregation of 'plugins' or 'bundles' that can be added to the platform configuration to change its behavior. Some such modular systems also often provide registration/discovery mechanisms that allow modules to integrate their behavior, allowing one module to invoke the methods or services of another.

The core of the idea of this invention is that the code responsible for processing a given parent tag can utilize modular components to handle the processing of its child components. Modular components are added to the system and specifically register an association with the child tag(s) they are capable of processing. The parent code invokes the child handler through a well defined callback interface.

This idea requires that the host runtime system be modular and provide a means of discovery of modular code components that can be executed and provide meta data for association purposes.

A key advantage of this invention idea over the more standard alternative pattern of revising the schema and generating a new parser is that when this invention idea is implemented in a dynamically reconfigurable modular code execution platform (such as a Java runtime engine), new code modules for handling child elements can be added / updated to the system on the fly without restarting the parent code process. This allows the parser to be reconfigured without restarting the system.

The idea works in the following manner.

At some point we assume we have and are executing program code responsible for processing a parent node of a markup document. This may or may not be the root node of the document hierarchy. We will refer to this as the 'parent code'.

Using the syntax appropriate for the particular markup language (for example the bracket (<tag> .. </tag>) syntax of XML) the paren...