CA 02608514 2007-10-29
SYSTEM AND METHOD FOR BUILDING A BACKEND TOOL
CONNECTOR IN SUPPORT OF HETEROGENEOUS DATA SOURCES
TECHNICAL FIELD
[0001] This disclosure relates generally to application development
environments and in particular to a system and method for connecting to
heterogeneous data sources.
BACKGROUND
[00021 Due to the proliferation of wireless networks, there are a continually
increasing number of wireless devices in use today. These devices include
mobile telephones, personal digital assistants (PDAs) with wireless
connectivity, two-way pagers and the like.
[0003] With the increasing use of wireless devices, the demand for
additional appiications has also increased. For example, in addition to
providing access to email, wireless devices may also provide applications that
acoess various data sources such as music downloading services, weather
reports, stock information, etc.
[0004] Creating appiications for wireless devices can present various
difficulties to application developers. For example, the devioes typically
have
iimited processing power and limited storage and/or memory available.
Furthermore, with the proliferation of the various wireless devioes, it may be
difficult to generate applications that will run on more than one device or
type
of device. Wireless applioation development may be facilitated through the
use of an Integrated design environment (IDE). An IDE may provide a visual
method for designing an application.
[0005] Wireless applications may connect to a web service that provide
infarmation to the wireless application. The web services are described using
web service description language (WSDL) which describes the contract (or
interface) provided by the web service that can be used when accessing the
-1-
CA 02608514 2007-10-29
service. Web services defined by WSDL are Increasingly used as a way to
allow various systems to oommunicate and exchange information.
[0006] An IDE may provide functionality for generating an application
definition based on a WSDL document. This functionaliiy may be uaed to
quickly create wireless applications that receEve information from the web
service. However, in order to generate the application definitions from the
WSDL description the IDE must have knowledge of the WSDL language and
how to generate the application definition (i.e. the application components
and
how they are cross-connected) from the WSDL dooument.
[0007] While there is a proliferation of web services described using
WSDl., it is desirable to be able to create applications that can communicate
with a data source that Is not described in WSDL. For example, a database
may provide remote aecess, however the contract (or Interface) used for
acoessing the information may not be described in a WSDL. It is difficult to
provide an IDE with the functionality of generating an ad-hoc appiicafiion
definition from a data source (i.e. a web service, database, proprietary
service
etc.) that are not described using WSDL.
[0008] It Is desirable to have an IDE that may be extended to add
functionality for generating an application definition from a data source that
is
not described using WSDL.
BRIEir DESCRIPTION OF THE DRAWINGS
[0009] An embodiment of the present disciosure will now be described by
way of example with reference to the following drawings in which:
Figure 1 depicts in a block diagram, a prior-art integrated design
environment;
Figure 2 depicts In a block diagram, an IDE and plug-in in accordance
with the present disclosure;
Flgure 3 depicts In a block diagram an IDE and plug-in in accordance
with the disciosure; and
-2-
CA 02608514 2007-10-29
Figure 4 shouvs in a flow chart a method of using an IDE to create an
application definition in accordancs with the disclosure.
SUMMARY
[0010] In accordance with the present disclosure, there is provided a plug-
in for use with an authoring application for facilitating development of a
wireless application. The wireless application is for communioating with a
data source described by a generic schema. The plug-in comprises a plug-in
InterPace for interfacing with the authoring application, the plug-in
interface is
defined by the authoring program. The plug-in further comprises logic for
determining the functionality exposed by the data source desaribed by the
generic schema, and a service descriptor generator for generating a service
descriptor of the data source, the generated service descriptor being
described using a schema common to the authoring application.
[0011] In accordance with the present disclosure, there is further provided
a method for using a plug-in with an authoring application for facilitating
development of a wireless application. The wireless application is for
communication with a date souroe described by a generio schema. The
method comprises providing a plug-in interface for interfacing with the
authoring appiication, the plug-in interface defined by the authoring program.
The method further comprises determining the functionality exposed by the
data source described by the generic schema, and generating a service
descriptor of the data source, the generated service descriptor being
described using a schema common to the authoring application.
[0012] In accordance with the present disciosure, there Is further provided
a computer-readable medium storing instructions or statements for use in the
execution in a computer of a method of using a plug-in wifh an authoring
applioation for facilitating development of a wireless application, the
wireless
application for communication with a data source described by a genefic
schema. The method comprises providing a plug-in Interface for interFacing
with the authoring application, the plug-in interface defined by the authoring
-3-
CA 02608514 2007-10-29
program. The method further comprises determining the functionaiity
exposed by the data source described by the generic schema, and generating
a service descriptor of the data source, the generated service descriptor
being
described using a schema common to the authoring application.
[0013] In accordance with the present disciosure, there Is also provided a
propagated signal carrier carrying signals containing computer-executable
instructions that can be read and executed by a computer, the computer-
executable instructions being used to execute a method of using a plug-in with
an authoring appiioation for facilitating development of a wireless
application, the wireless application for communication with a data source
described by a generic schema. The method comprises providing a plug-in
interface for interfacing with the authoring application, the plug-in
interfaoe
defined by the authoring program. The method further comprises determining
the functionality exposed by the data source described by the generic
schema, and generating a service descriptor of the data source, the
generated service descriptor being described using a schema common to the
authoring application.
DETAILED DESCRIPTION
[0014] Figure 1 depicts in a block diagram, an example of an integrated
design environment (IDE) 105. The IDE 105 can be used by developers to
create applications. The IDE 105 has functionality 110 for generating a
component application definition 115 from a web service 120 described by a
web service description language (WSDL) document 122. The functionality
110 reads the WSaL definifiion and generates the application definition. The
functionafity 110 Is able convert WSDL elements to the application component
definitions and the cross-connection of the components.
[0015] In order to create an application for connecting to a web service that
is not defined by a WSDL document, the developer must define the
component definitions. In order to provide an IDE with the functionality to
generate the application definition from the data schema, it would be
-4-
CA 02608514 2007-10-29
necessary to add the functionality to the IDE, that is, essentially provide
the
developer with a new version of the IDE with the functionality built in,
[0016] Figure 2 depicts in a block diagram, an example of an authoring
application 200 and plug-in 230, in accordance with an embodiment of the
present disclosure, The authoring application 200 is described herein as an
IDE 200. However it is understood that the authoring application 200 may
include, for example, a rapid application development (RAD) tool, a text
editor, etc. The IDE 200 has functionality (referred to as an application
definition generator) 110 for generating an application definition from a
known
definition language type, for example WSDL. This known definftion language
will be referred to as the IDE description language for clarity. The IDE
description language is described herein as being WSDL, however one skilled
in the art will recognize that an iDE could be designed to use a different
language as the IDE description language.
[0017] The IDE 200 may create an application as a definition of data
components, message oomponents and screen oomponents. The component
definitions 115 may be written in extensible ,markup language (XML) and so
be common to a large number of platforrns, or devices. When defining an
application as a set of components, the data may represent application
information, such as for example, the price of a stock. Screen components
may describe how to display the information on particular devices and
message components may describe how data is transferred between a server
and the wireless device. For example, when creating a component
application, the visual IDE may allow a developer to create the screen
components using a drag and drop approach (for example, creating a label,
button, text box etc.). The IDE may allow the developer to define the data
components and the message components, as well as how each component
is interconnected to another. The ID5 is used to generate an application
definition that may be uploaded into an application repository and registry.
The appiication may then be provisibned on A wireles$ device, such ai3 for
example, a smartphone.
~5-
CA 02608514 2007-10-29
[00181 The IDE 200 further has functionality (referred to as a plug-in
receptacle) 212 for connecting to a plug-in 230, The plug-in 230 and the plug-
in receptacle 212 (also referred to as an extension-point) implement a plug-in
interface. The plug-in interface may be provided through a lightweight
software componentry framework. The plug-in interface describes how the
plug-in 230 and plug-in receptacle 212 can communicate with each other.
The plug-in interface may be described as an API, in an XML document, or
other appropriate means. The plug-in receptacle 212 allows the use of the
plug-in 230 to generate a description of the data source in the IDE 200
description language. The It7E description language is common to both the
plug-in 230 and the IDE 200, and allows the plug-in 230 to generate a
description that can be understood by the IDE 200. The IDE 200 may then
use the generated IDE description language description of the data source to
create an application definition for an application that is able to access the
data source 120.
[0019] The IDE 200 may provide an extension point, for example named
'backends', which constitutes the backbone of the receptacle 212 for various
custom data source plug-ins 230. An example of a plug-in receptacle 230
manifest is described below.
<plugin
id-"net.rim.wica.toois,studio.datasource.connector"
name="Connector Plug-in"
version="1Ø0"
provider- name="RIM"
ciass="net.rim.wica.tools.studio.datasource.connector.ConnectorPlugin
n~
<runtime>
-~Iibrary name="dsconnector.jar">
<export name="*"/>
</library>
</runtime>
<requires>
<Import plugln="org.ecllpse.core.runtime,compatibility"/>
<Import plugin="org.xmisoap.schemas,wsdl" export="firue/>
</requlres>
{extenslon-point
id="backends" name="backends"
schema="schema/backends.exsd "/>
</plugln>
-6-
CA 02608514 2007-10-29
[0020] The above example describes the general plug-in receptacle 212
provided by the IDE 200. The IDE 200 may provide an extension point where
the custom plug-ins 230 can be hooked. An example of an extension point
schema definition is provided below for use when creating a plug-in 230 to
hook with the extension point.
<schema
targetNamespace="net.rim.wica.tools.studio.datasource.connector">
<annotation>
<applnfo>
<meta.schema
pI ugln="net. rlm.wlcs.tools.studlo.datasou rce. co nnector
id="backends"
name-"backends"/>
</appinfo>
<documentation>=
Backend extenslon po!nt to hook heterogeneous data source
connectors
</documentation>
</annotation>
<element name="extension">
<complexType>
<sequence>
<element ref^"backend" minOccurs="0"
max0ccurs="10"/>
4/sequence>
<attribute name="point" type="string" use=prequired">
cannotation>
<documentation>
</documentation>
</annotation>
</attribute>
<attribute namem"id" type-"string">
<annotation>
<documentation>
</documentation>
</annotation>
</attribute>
<attribute name="name" type="string">
<annotation>
<dotumentation>
</documentation>
</annotation>
</attrlbute>
</complexTypey
c/element>
<element name="backend">
-7-
CA 02608514 2007-10-29
tcomplexiype>
zattribute name="Id" type="string">
<annotatlon>
tdocumentation.
</documentation>
</annotation>
</attribute>
<attribute name="descriptlon" typen"string" use="required">
<annotation>
<documentation>
</documentatSon>
</annotation>
</attribute>
<attribute name="ciass" type="string">
<annotation>
<documentation>
</documentation>
<appInfo>
Emeta.attrlbute kind="java"
basedon="net. rim.wica.toois,studio.datasources.connector.Iconnector"
</appInfo>
</annotation>
</attributey
<attribute name="backendType">
<annotation>
<documentation>
</documentation>
</annotation>
</attribute>
</complexType>
c/element>
<annotation>
<applnfo>
<meta.section type="since"/>
</appInfo>
<documentation>
[enter the first release in which this extension point appears]
c/documentation>
</annotation> <annotatlon>
<applnfo>
<meta.sectlon typeF"examples"/>
</appInfo>
<documentation>
[enter extensio[l point usage example]
</documentation>
-4/annot8tion>
<annotation5
<applnfo>
-$-
CA 02608514 2007-10-29
<meta.sectlon type="aplInfo"/>
</appInfo>
<documentation> Center API information]
</documentation> </annotatlon>
<annotatlon>
<apptnfo>
4meta.section type="impiementation"/>
</appInfo>
<documentation>
[enter information about supplied informatlon of this extension
point]
</documentation>
t/annotation>
<annotation>
<appInfo>
cmeta.section type="copyrIght"/>
</appInfo>
<documentation>
</documentatlon> </annotation>
</schema>
[0021a Using the above schema definition, an example of a custom plug-in
interface is provided below, The example plug-in 230 is for aocessin$
database data sources 120.
<plugln
ld="com,my_company.studio.datasource.connector.dbc"
name="Dbc Plug-in"
version="1. 0.0"
provider-name="My-Company"
class = "com. my_company.studio. datasource, connector.dbc. DbcPiugin"
<runtime>
<library namQ="connector-dbcjar">
<export name="*"/>
</Ilbrary>
,~/runtime>
<requires>
<Import plugin="org.eclipse,uI"/>
<import pfugin="org.eclipse.core,runtime"/>
<import plugin="net.rim.wica.tools.studio.datasounce.connector/>
</requires>
<extension
pointz"net.rirn.wica.tdols,studlo.datasource.connector.backends">
<backend backendType="database"
class="com.my_company.studlo.datasource.connector.dbc. DBConnector"
description="Database connector plugin" idndatabase"/>
</extension>
4/plugin>
-$-
CA 02608514 2007-10-29
[0022] In this example, the custom plug-in 230 described by the above
manifest depends on a 'net.rim,wica.tools.studio.datasource.connector'
receptacle. The custom plug-in 230 desoribes a DBConnector class for
hooking to the 'backends' extension point of the IDE 200.
[0023] The DBConnector implements the functionality required to
communicate with various database data source(s), The DBConnector class
provides an abstract class that can be used to provide functionality for
connecting to a database that is described by a generio schema. The
DBConnector may be used to generate a description of the database for the
IDE 200 in the IDE description language common to the plug-in 230 and IDE 200,
such as WSDL, or enhanced WSDL. An example of the DBConnector
class is described below.
Package com.my_company.studio.datasource.connector.dbc;
Import org,xmisoap.schemas.wsdl.DocumentRoot;
Import net.rim.wica.tools.studio.datasource.connector.IConnectar;
Import net.rlm.wica.tools.studio.datasource.connector.Iconnectorinfo;
Public class DBConnector Implements IConnector
{
private IDBConnectorinfor _connectorInfo
D bcFacto ry. eI N STA N C E. createID BCon nectorInfo ();
private static DbcPackage -condbcPackage = DbcPackage.eYNSTANCE;
private static org.xmisoap.schemas.wsdI.WsdiPackage _wsdlPackage =
org.xmisoap.schemas,wsdl. WsdlPackage.einstance;
private DocumentRoot _wsdlRoot;
public DocumentRoot getpocumentRoot(zconnectorInfo connectorInfo)
throws Exception {
connectorinfo = (IDBConnectorinfa) connectorInfo;
//set the driver for connecting to the datasource(Ie JDBC)
CIass.forName(driver) }
//get the connection for the url & credentials
conn 4 DriverManager.getConnection(url, loginid, pass);
//get the databaseMetapata object or other means of interrogating
//the schema
DatabaseMetaData dbmd = conn.getMetaData();
/JgQt tho schema/catalog for the user or database
//get tables, columns, procedures and procedureColumns for the
//respective schema or catalog
-10-
CA 02608514 2007-10-29
//present a dlalog to select a sub-schema: stored-procedures can
//be mapped dlrectly to equivalent operations; SEI.ECT'
//statements on tables can be used to build other Input messages
//and their resultSets to build the correspond{ng output message.
//generate WSDL from sub-schema
return _wsdlRoot;
}
[0024] In the main method above, getDocumentRoot, a parameter of type
IConnectorlnfo Is passed when it is called from the IDE 200 through the plug-
in receptacle 212. The IConnectorinfo parameter hoids the data source URL,
credentials (i.e., username and password) and whatever is required to access
the schema. From the schema, a description of the data source is generated
in the IDE description language as the root document. The IDE description
language document has operafiions that were transformed from entities in the
schema. The plug-in class is designed to generate a description of a data
source 120 based on the specific schema description 122 of the data source
120.
[0025] For a database schema, the meta-data of the database schema is
analyzed for stored-procedures, functions and user types. Procedures and
user functions can translate into operations. A result set may then be defined
as arrays of complexTypes. Ad-hoc operations may be built from tables and
views using the Structured Query Language (SQL) language (or other
language as used by the data source). Special WSDL bindings can be used
to express the underlying SQL statements for the different operations. The
SQL statements may be included in an enhanced WSDL description if the
enhanced WSDL is understood by both the plug-in 230 and IDE 200.
[0026] Before the DBConnector class makes a connection to the database,
the connection is first prepared. This is achieved by setting the appropriate
driver, url and credentials for the connection. These settings may be passed
to the DBConnector using the IConnectorinfo interface. The DBConnector
may be configurzd for choosing the correct driver and other characteristics.
[0027] The IConnectorinfo interface may be used to collect the necessary
information for establishing a connection to the data source. An example
-~1-
CA 02608514 2007-10-29
schema of an IConnectorlnfo interface that is specialized for establishing a
connection to a database data source 120 is provided below. <xsd ~schema
targetNmmespace="http:///net/rim/wica/tools/studlo/datasourcelconn
ector/dbConnector.ecore"
xmins; net.rim. wica.tools.studlo.datasource.connector= "http:///net/rim
/wica/tools/studio/datasource/con nector. ecore"
xmins: net.rlm.wica.tools.studio.datasource.connector.d b="http:///net/
rim/wica/tools/studio/datasource/connector.dbConnector.ecore"
xmlns,.xml="http-://www,omg.org/XMI"
xmlns.-xsd--"http://www.w3.org/2001/XMLSchema">
-cxsd:lmport
narnespace="http:///net/rim/wica/tools/studio/datasource/connector.e
core"
schemaLocatioin="connector.xsd"/>
<xsd:lmport
namespace-"http://www.omg.org/XMI"
schema l.ocati on Q "XMI.xsd"/>
<xsd:complexType name=IDBConnectorInPo">
<xsd : compl exContent>
<xsd:extenslon base = .
"net. rlm.wlca.tools.studio.datasok,rce. connector: Icon nectorInfo">
<xsd:attribute name="drlver" type="xed:string"/>
<xsd:attribute name="user" type="xsd:string"/>
axsd:attrlbute name="password" type="xsd:string"/}
<xsd;attribute name="driver ld" type="xsd:string"/>
<xsd:attribute namem"schema" type= "xsd:string"/>
</xsd:extensiona
</xsd :complexContent}
</xsd:complexType>
</xsd: element name="IDBConnecWrinfo"
typa="net.rim.wica.tools.studio,datasource.connector.db:IDBConnectorInf
O"/>
</xsd:schema>
[0028) The functieonality of the service descriptor generator 232 may be
included in the plug-in 230 (for example, the DBConnector class described
above), or it may be implemented separate from the plug-in 230. Regardless
of the specific implernentation details, the service descriptor generator 232
provides prooessing of the data source schema 122 Into the IDE description
language (for example WSDL or enhanced WSDL) and XML schema
description (XSD) schema components and vendor specific (specialized)
extensions that deal with speciflcs when exploring the data source schema
122 and generating the IDE description language.
[0029] The plug-in 230 implements the plug-in interface 234 in order to
facilitate communication with the IDE 200 through the plug-in receptacle 212.
-12-
CA 02608514 2007-10-29
The plug-in 230 also provides logic 233 for connecting to a data source 120,
and expioring the data source 120. The logic 233 for exploring the data
source 120 is designed to communicate with the data source 120. From the
data source schema 122, the logic 233 determines the functionality exposed
by the data source 120 and how to communicate with the data source 120 in
order to use the functionality of the data source 120. The service desariptor
generator 232 uses this information when generating the IDE description
language description of the data scurce 120.
[0030] A plug-in connector may be generated when a plug-in 230 Is created. The
generated connector can be included in a gateway server to
which a wireless device oonnects. The wireless deviad accesses the data
source 120 through the gateway, using a wireless application. The generated
connector provides a similar function to the application, as the plug-in 230
achieves for the IDE 200. The wireless application connects to the gateway
server which uses the connector to convert oommunieations (i.e., In coming
and out going messages) from the application into a format expected by the
data source 120 (i.e., as descnbed by the data source schema definition), and
communications from the data source 120 into the format expected by the
wireiess appiication.
[0031] A plug-in 230 can be created for creating an IDE description
language definition of a data source 120. The plug-in 230 may be created in
a design environment such as Eclipse (TM). Eclipse provides a frameworic
model for creating plug-ins. As described above, the plug-in 234 and plug-in
receptacle 212 of the IDE must implement the same interface, such as
extertsion-point.
[0032] Figure 3 depicts in a block diagram an example of the
communication between an IDE 301, a plug-in 310 and data source 120, in
accordance with an embodiment of the present disclosure. The IDE 301
provides an application developer with the ability to create an application
definition using a plug-in 310 for connecting to a data source 120. The IDE
301 inciudes a description language 302 that can be used by the plug-in 310
to describe the data source 120. As described above, the description
-13-
CA 02608514 2007-10-29
language may be, for example, WSDL or enhanced WSDL that is able to
describe the data source 120. The IDE 301 may also comprise a backend
connector wizard 304 that provides functionality for using a desired plug-in
310. The functionality of the wizard 304 may Include for example, seiecting
the desired plug-in 310, allowing for plug-in 310 properties to be set, etc.
The
IDE 301 also comprises a receptacle 305 of the plug-in Interface 306. The
receptacle 305 is a backend extension point. The extension point may be
based on, or extend a plug-in framework provided by the IDE 301.
[00331 The plug-in 310 may extend a plug-in framework. This framework
for example could inciude an abstract piug-in class (represented as 312). The
plug-in 310 connects to the plug-in interface 306 implemented by receptacle
305. The corresponding plug-in interface is represented as 314. The
interface 308 may be comprise an IConnector structure and an ICnnectorinfo
structure. The plug-in side Interface 314 may Implement a method defined by
the interface, such as getDocumentRoot(IConneetorinfo) for calling the logic
of the plug-in. [0034) The plug-in 310 comprises a discovery page 315
associated with a
particular data source 120. The discovery page 315, may comprise, for
example, information received from an IConnectorinfo structure. This
information may comprise a uniform resource locator (URL) 316 of the
particular data source 120, a username 317 and password 318 far connecting
to the partlcular data source 120. The schema 319 of the discovery page may
be obtained from the logie of the plug-in 310 for expioring the functionality
exposed by data source 120 using the generic schema type that Is used to
describe the data source 120.
[0035] The plug-in 310 uses the information of the discovery page 315 to
connect to the data source 120, when for example getDocumentRoot is called
via the plug-in interface 306. The plug-in 310 explores the functionality of
the
data source 120 and generates an IDE description language description of the
data source 120 using a service descriptor generator 320. The IDE
description language may be, for example, enhanced WSDL, The enhanced WSDL
description may be returned to the IDE 301 via the plug-in interface
-14-
CA 02608514 2007-10-29
306 as an enhanced DocumentRoot, that may have the bindings and services
extended. Optionally, the plug-In 310 may provide a selector 330 for selecting
a subset of the functionality exposed by the data source 120 to include In the
DocumentRoot description.
100361 Using an IDE 200, 301 with an appropriate plug-in receptacle 212,
305 and a plug-in 230, 310 for connecting to data sourc0120, a developer
may quiokly create an application definition 115 by connecting to and
exploring a data source 120. The application definition 115 may be further
modified before the application definition 115 Is published to a repository
and
registry and afterwards provisioned to a devioe.
100371 Figure 4 shows in a flowchart an exampie of a method of using an
IDE 200, 301 to create an application definition, in accordance with an
embodiment of the present disclosure. The IDE 200, 301 provides a designer
the ability to select the data source type, which determines the plug-in type
to
use (405). Once the designer's selection Is received, a U'Ftl. is received
(410)
for specifying the particular data souroe 120. The funationaiity of the plug-
in
230, 310 is then called using the plug-in Interface 306. In one embodiment,
this Is achieved by calling the getDocumentRoot (1Connectorinfo) method
(415). The plug-in receives the IConnectorlnfo specifjring connection
information for connecting to the data source 120. The plug-in 230, 310 sets
an appropriate driver to be used when connecting to the data source 120
(420), and the connection credentials (425). The plug-in 230, 310 then
connects to the data souroe 120 and explores the functionality exposed by the
data sourc 120. In a particular embodiment this is done by calling
getConnection and g tMetaData (430). Once the meta-data is received, the
plug-in 230, 310 may receive a selection of the desired exposed functionality
to include in the description (435). The plug-in 230, 310 next generates the
DocumentRoot (440) and returns it to the IDE 200, 301 using the plug-in
interface 305. Using the Document Root, expressed in for example enhanced
WSDL, the IDE 200, 301 generates the application definitions necessary for
implementing the data source description (445). The IDE 200, 301 may also
generate the bindings necessary for connecting the application components to
-15-
=
CA 02608514 2007-10-29
the data source 120 (450). The IDE 200, 301 may finally save the application
components and bindings (455).
(0038] The systems and methods according to the present invention may
be implemented by any hardware, software or a combination of hardware and
software having the above described functions. The software code, either in
its entirety or a part thereof, may be stored in a computer-readable memory.
Further, a computer data signal representing the software code which may be
embedded in a carrier wave may be transmitted via a communication network.
Such a computer-readable memory and a computer data signal are also
within the scope of the present patent disclosure, as well as the hardware,
software and the combination thereof.
[0039] While particular embodiments of the present invention have been
shown and described, changes and modiflcations may be made to such
embodiments without departing from the true scope of the invention.
-~8-
