WO2004027663A2

WO2004027663A2 - A data processing system and method

Info

Publication number: WO2004027663A2
Application number: PCT/IE2003/000128
Authority: WO
Inventors: Jonathan Boylan; Rory Connolly; Eoin Kirwan; Ann Mccorry; Alan Molloy
Original assignee: Neos Financial Systems Limited
Priority date: 2002-09-23
Filing date: 2003-09-23
Publication date: 2004-04-01
Also published as: AU2003263566A1; IE20030701A1; AU2003263566A8; WO2004027663A3; IES20030702A2

Abstract

A data processing system (1) has a processor (2) which has an initialisation function for setting up a framework (50) of product or service object oriented classes and subclasses. Each sub-class (31-34) is for a component of the service with a logical grouping of rules. A run-time function generates a particular instance of the service by instantiating a contract class framework (53) which is derived from the service class framework (50). The contract objects may be modified within control limits imposed by rules of an alteration class (37) of the service class framework. A document describing the service in general terms may be generated from the service classes.

Description

"A data processing system and method"

INTRODUCTION

Field of the Invention

The invention relates to data, processing systems for generating and managing services involving ongoing transactions.

Prior Art Discussion

European Patent Specification No. EP1303811 (also WO02/06954) describes a system for assembling a document for a contract conf ming a trade. Each object of the document includes a condition indicating whether an instruction associated with the condition should be executed. European Patent Specification No. EP1250667 (also WO00/67181) describes a system for processing contracts in which data, client, controller, and adapter components interact to process and cache data.

The above systems are examples of the prior art approach which is to provide functions to efficiently perform certain specific tasks to implement a service along a time-line. However, while this approach leads to efficient processing, it suffers from providing little versatility for variations across different service instances. For example, a loan contract for customer A may be required at the business level to have different rules for execution than a similar type of loan for customer B. While the first prior art document above appears to address the issue of versatility, it is at the document level as opposed to the overall service level.

The invention is therefore directed towards providing for both efficient and versatile set-up and implementation of services by a data processing system. SUMMARY OF THE INVENTION

According to the invention there is provided a data processing system comprising a processor, input and output interfaces, a memory, and a storage device, wherein the processor comprises:

an initialisation function for setting up an object oriented class of rules and data for a service; and

a run-time function for instantiating a contract object for a contract, being application of a specific instance of the service, said contract object inheriting said rules and data of the service class.

The service may be in a manufacturing environment such as a manufacturing process or a testing method. Alternatively, the service may be in the financial area, in which case it may alternatively be referred to as a product. In either case, the word service means that when implemented in the relevant environment there is a process involving ongoing transactions/events in real time.

In one embodiment, the initialisation function sets up a service framework of linked service classes, and the contract objects have inter-relationships mirroring a structure of said service framework..

In one embodiment, the service framework comprises a parent class and a plurality of component sub-classes, each component sub-class containing logically grouped rules according to a modular service breakdown into a service component.

The service framework allows modularity in set-up of the data processing system, and faster real time performance as individual objects operate autonomously to perform tasks In another embodiment, the initiahsation function stores a library of component subclasses and allows selection of desired component sub-classes to set up the service framework. This allows pre- validation of classes for improved system integrity and shorter lead times .

In one embodiment, the initialisation function establishes a test environment during which a service framework may be set up.

In one embodiment, the initialisation function validates selected component subclasses in the test environment, and releases sub-classes for a run-time environment only after validation.

In one embodiment, the initialisation function instantiates the contract objects from a contract class framework linked with the service framework.

In a further embodiment, the initialization function generates said contract class framework with a link to the associated service framework via a parent components class.

In one embodiment, the initialization function instantiates a plurality of N sets of service objects from the service framework, each set defining a particular unique instance of the service.

In one embodiment, the run-time function instantiates a plurality of M sets of contract objects from the contract class framework.

In one embodiment, the processor comprises a modification function allowing user- driven modification of contract objects only within limits inherited from the service class. In one embodiment, said limits are defined by attributes of a service class alteration object.

In one embodiment, the initialisation function automatically generates a document describing a service by outputting information attributes of the service class.

In another aspect, the invention provides a data processing system comprising a runtime function for instantiating a set of contract objects for a contract in which each object is for a component of a contract, and in which an initialization function generates:

a service framework comprising a parent product class and linked component sub-classes,

N sets of service objects instantiated from the service framework, each set defining a unique service;

a contract class framework linked with the service framework; and

in which the runtime function instantiates M sets of contract objects from the contract class framework.

DETAILED DESCRIPTION OF THE INVENTION

Brief Description of the Drawings

The invention will be more clearly understood from the following description of some embodiments thereof, given by way of example only with reference to the accompanying drawings in which:- Fig. 1 is a block diagram of a data processing system of the invention;

Figs. 2 and 3 are product and contract class diagrams; and

Fig. 4 is a flow diagram illustrating object-oriented structures for set-up of a contract by the system.

Description of the Embodiments

Referring to Fig. 1 a data processing system 1 comprises a back-office transaction processor 2 having a transaction database 3. A server 4 interfaces with the processor 2 to allow access to selected data by online users 5 and user systems 6 in a local area network (LAN) 7. At this level the system is conventional, and Fig. 1 omits detail such as multiple hardware units in a redundancy configuration and mirrored databases of the processor 2. However, the invention lies in the sof ware architecture to achieve greater versatility with required consistency for processing services.

In this specification the words "service" and "product" are used interchangeably to mean a type of contract. For example a product may be an insurance product offered by an insurance company and a contract would be a particular policy under that product. The data need not necessarily be financial. It could, for example, relate to a manufacturing process in which there is a service for testing manufactured items and another service for quality control procedures. In this example a contract may be a particular testing operating procedure for a particular item with a unique identifier. In all cases a service defines transactions involving data being captured and events being performed according to rules.

The processor 2 operates in an object-oriented manner to both set up and implement contracts involving multiple transactions for a time period. In an initialisation phase an initialisation function of the processor 2 establishes, under user instructions, a product object oriented class framework. Referring to Fig. 2 a product class framework comprises:

a container product class 30,

a policy fee sub-class 31,

an investment sub-class 32,

a regular premium sub-class 33, and

an assurance sub-class 34.

Fig. 2 also shows a product components object 35 from which the sub-classes 31-34 are inherited. The product components class 35 is linked with a contract components class 40. This is a link between the product class framework and a contract class framework, as described in more detail below. This diagram also shows an alteration class 37 form which alteration objects are instantiated to modify contract objects within limits imposed by the product class framework. .

The product class framework is for a particular type of product. Each of the subclasses 31-34 includes methods for execution of pre-defined rules for a component of the product. For example, the sub-class 34 includes in its methods the rules associated with assurance cover, such as charging rates and aEowable age ranges. The regular premium sub-class 33 includes in its methods rules for allowable payment methods, payment frequencies, and premium limits. The investment subclass 32 includes in its methods allowable investment funds and fund management fees. The business nature of the components is not relevant to the invention, the important point being that the product (service) is broken up into components in the product class framework.

The parent class 35 includes product-level summary information, which can be used to generate reports or Web site information describing the product.

The initialisation function comprises a user interface which allows a user to graphically add, delete, and modify the product class framework. This can only, however, be performed in a test environment offline to ensure system integrity. This interface automatically validates any product class modifications. A framework of product classes is only released to the run-time environment after validation.

Validated product component sub-classes are stored in a library and may be selected from the library to develop fresh product class frameworks.

A document describing a product for the hosting organisation can be automatically generated by instantiating the classes 30-34 and outputting the text and graphical information attributes. This information sets out the general rules and other information describing the product both for staff and customers. In a manufacturing environment, instantiation of the classes 30-34 provides a document describing for example, the testing steps for testing of a particular type of manufactured item to generate a standard operating procedure document.

Referring to Fig. 3 the processor 2 also initializes a contract class framework. The framework comprises a parent class 40 for a contract and component contract subclasses 41-45 for various contract components. The parent class 40 is the link to the product class framework.

Thus, the processor 2 initializes a product class framework and a contract class framework linked by the class 40. The product class framework is instantiated to provide a set of objects for a particular product. For example, the product class framework may relate to an industry-wide type of insurance policy such as car insurance. There are a number of sets of product objects instantiated from this one framework. Each such set of objects defines a single car insurance product offered by a company. There is a contract class framework associated with the product class framework, the contract class framework mirroring the product objects by having the same mterlinking structure and methods. A particular contract such as a car insurance policy for a person is instantiated form the contract class framework.

Referring to Fig. 4, this is illustrated graphically. There is at least one product class framework 50, the classes of which define rules for a type of product. This is instantiated N times, each time to generate a set 52 of product objects for a particular product. The initialization function also sets up a contract class framework 53 mirroring in contract terms the product class framework. The contract class framework 53 is used to instantiate M contracts 54. Each contract 54 comprises a set of objects for a particular contract such as an insurance policy for an individual.

A contact may be modified by modifying the contract objects 54. Before modification, the contract objects have inherited all of the methods (incorporating rules) and attributes of the relevant contract class framework 53. These in turn reflect limits imposed by the alteration product framework class 37. These data and rules are at the meta level. The modifications implemented are strictly limited within ranges inherited from the product class framework 50.

This logic includes the ability to assign to any error messages produced by a particular validation a severity which governs the progression allowed on the case until the issue is resolved. Error messages may be also be overridden on individual cases, so again minimising the need for new creations. It will be appreciated that the invention provides for simple and convenient set up of services or products, with modular groupings of rules and attributes. Also, it allows individual contracts to be generated very quickly by simply instantiating an object oriented class structure. Further customisation for the specific circumstances is performed in a controlled manner within limits associated with the product class framework

The invention is not limited to the embodiments described but may be varied in construction and detail.

Claims

1. A data processing system comprising a processor, input and output interfaces, a memory, and a storage device, wherein the processor comprises:

2. A system as claimed in claim 1, wherein the initialisation function sets up a service framework of linked service classes, and the contract objects have inter-relationships mirroring a structure of said service framework.

3. A system as claimed in claim 2, wherein the service framework comprises a parent class and a plurality of component sub-classes, each component subclass containing logically grouped rules according to a modular service breakdown into a service component.

4. A system as claimed in any of claims 2 or 3, wherein the initialisation function stores a library of component sub-classes and allows selection of desired component sub-classes to set up the service framework.

5. A system as claimed in any preceding claim, wherein the initialisation function establishes a test environment during which a service framework may be set up.

6. A system as claimed in claim 5, wherein the initialisation function validates selected component sub-classes in the test environment, and releases subclasses for a run-time environment only after validation.

7. A system as claimed in any preceding claim, wherein the initialisation function instantiates the contract objects from a contract class framework linked with the service framework.

8. A system as claimed in claim 7, wherein the initialization function generates said contract class framework with a link to the associated service framework via a parent components class.

9. A system as claimed in claim 8, wherein the initialization function instantiates a plurality of N sets of service objects from the service framework, each set defining a particular unique instance of the service.

10. A system as claimed in claim 9, wherein the run-time function instantiates a plurality of M sets of contract objects from the contract class framework.

11. A system as claimed in any preceding claim, wherein the processor comprises a modification function allowing user-driven modification of contract objects only within limits inherited from the service class.

12. A system as claimed in claim 11, wherein said limits are defined by attributes of a service class alteration object.

13. A system as claimed in any preceding claim, wherein the initialisation function automatically generates a document describing a service by outputting information attributes of the service class.

4. A data processing system comprising a run-time function for instantiating a set of contract objects for a contract in which each object is for a component of a contract, and in which an initialization function generates:

a contract class framework linked with the service framework; and

15. A computer program product comprising software code for performing the operations of a data processing as claimed in any preceding claim when executing on a digital computer.

16. A data processing system substantially as described with reference to the drawings.