Requirements Management Tool for Busy System Analysts
The first and only XML-based requirements management software for handheld devices ^sm.

Architecture Overview

Rambutan consists of two application software: a desktop application and a handheld application. The desktop application is programmed to the Java 2 Standard Edition API (J2SE) while the handheld application is programmed to the SuperWaba API. Both applications are coded in the Java programming language. Using a common implementation language allows the two applications to share some common code – these cross-platform components contains simple algorithms and interface classes that do not rely on either API to function.

Both applications are roughly divided into two layers: a user interface layer, and a data model layer. Currently, the desktop application uses the Swing GUI library available with J2SE (note that Swing is not the only user interface option available in the platform). Since a handheld device is more limited, the handheld application has little option besides using SuperWaba's GUI library.

The two applications shares the RQML Abstraction component. This component is a set of interfaces that defines the RQML data model. In turn, these interfaces are implemented by both the Desktop Model and Handheld Model components. Access to the RQML implementations in both applications utilizes this abstraction as much as possible. Therefore consistency of the data models between the handheld and desktop is enforced – changes to these interfaces will ripple to both implementations in the handheld and desktop. Likewise, a method signature change in the implementing model of one application will require the change to be mirrored in another application. 

Handheld Application

The handheld application actually has three major layers: the user interface (GUI) layer, the data model layer, and the RQML implementation layer. Being a shared component, classes in the RQML Abstraction layer is also included in the handheld application. All layers in the handheld application rely on the SuperWaba API classes.

The GUI layer implements the user interface. Classes in this layer mostly extend from SuperWaba's Window class. Access to the handheld's data by the GUI is done solely through the Handheld Model or the RQML Abstraction layers.

Classes in the Handheld Model layer provide services to manage RQML elements to the GUI. Most operations done by the model rely only to the method signatures defined by the RQML Abstraction component to access the RQML elements. One major exception to this includes object instantiations of the RQML elements (in which the model acts as an abstract factory to its clients).

Since the classes in the RQML Abstraction are all abstract interfaces, they must be implemented to be useful. Straightforwardly called the RQML Implementation layer, these classes implement those interfaces for use in the handheld application. Shielded from the GUI by the Handheld Model and RQML Abstraction layers, internal implementation changes to this layer will not affect the GUI. 

Desktop Application

Similar to its handheld counterpart, the desktop application also consists of three major layers: the user interface, model, and RQML implementation. The RQML Abstraction layer contains the same set of classes as in the handheld application. All layers in the desktop application rely on the J2SE API.

The user interface of the desktop application uses the Swing GUI library available in J2SE. Although its functions are similar to the handheld, the desktop GUI takes advantage of the larger screen and richer user interface capabilities typically available in a desktop computer. Access to the data is also done solely through the model and the RQML Abstraction classes. 

Since a desktop computer offers greater processing and richer user interface capabilities, the desktop model has more features to take advantage of this fact. Therefore, the desktop data model has different methods signatures and implementations from the handheld’s model. Like the handheld, it also relies on the RQML Abstraction interfaces to manipulate the RQML elements in the model and acts as a factory class to instantiate their implementations.

Implementation of the RQML Abstraction layer in the desktop application is different from the handheld. Instead of storing RQML data itself, these classes rely on XML DOM objects to represent the data in-memory. Therefore, classes in this layer are collectively called Element Adapters. The DOM implementation library used is Apache Xerces, an open-source XML parser. Since these adapters communicate with the parser solely through the DOM interfaces provided, another DOM-compliant XML parser besides Xerces may alternatively be used.

Bridge Classes

The desktop application architecture pictured previously depicts only a part of the architecture. A Bridge component is purposely hidden from the picture to improve its legibility. This component is used by the desktop application to access the handheld's data. It handles the conversion between the desktop and handheld models. 

When the user opens a handheld document or saves a handheld document using the desktop application, its user interface calls the Bridge Facade to read the handheld data and loads the data into the in-memory desktop model and vice-versa. This facade in turn delegates the request to the appropriate Import Facade or Export Facade components. The two facades then handle the import or export, respectively.

The Import Facade uses a set of First-Class Importer classes to load data from the handheld model into the desktop. Each of these importer classes imports a certain type of first-class RQML element.

Analogically, the Export Facade uses a set of First-Class Exporter classes to save data from the desktop into the handheld model. Similar to the importers, there are one-to one mappings between the element exporters and an RQML First-Class element type.

Both of the import and export facades relies on a Copy Facade to transfer data between RQML elements. In turn, the facade uses a set of Element Copier classes to copy the data. There are one-to-one mappings between a copier class and an RQML element (both first and second class elements). These copiers only depend on the RQML Abstraction interfaces – they have no knowledge of the underlying implementations of these interfaces. Thus, the copiers may be used to implement RQML importers and exporters of other data models in the future.

The import and export facades interact directly with the both handheld and desktop data models. Acting as a client to both models, they fetch and store RQML data between the two model instances.

Program code for the handheld model is run in the desktop so that the handheld-formatted data may be read and transferred into the desktop model. Although the handheld model is programmed to the SuperWaba API, this is possible due to the simulation layer (SuperWaba to Java bridge) provided by SuperWaba that allows its programs to run on Java 1.1. Thus, there is no need to duplicate code from the handheld application to read the handheld-formatted data.