WO2006131814A2

WO2006131814A2 - Document processing system and method computer readable medium

Info

Publication number: WO2006131814A2
Application number: PCT/IB2006/001489
Authority: WO
Inventors: Stuart Alexander King
Original assignee: Stuart Alexander King
Priority date: 2005-06-07
Filing date: 2006-06-07
Publication date: 2006-12-14
Also published as: GB0511607D0; WO2006131814A3

Abstract

A document processing system is disclosed comprising at least one incoming document controller (B) for receiving at least one document (A) having a format associated with the controller (B) that the controller (B) can identify. Each document (A) may comprise at least one data field comprising a field name and a value within the data field, which the controller (B) is able to retrieve. The system further comprises a participant identifier module (C) for receiving the data field value retrieved by the controller (B) and the format identifier for the document (A) and for determining at least one first mapping identifier for the identified format. A mapping control module (D) is provided for receiving the first mapping identifier and for calling a first mapping instance corresponding to the first mapping identifier, wherein the first mapping instance translates the data field name to define an independent data structure (F).

Description

DOCUMENT PROCESSING SYSTEM, METHOD AND COMPUTER

READABLE MEDIUM

BACKGROUND OF THE INVENTION

This invention relates to a document processing system, method and computer readable medium.

In an example embodiment, the invention relates to a collection of software modules, and the use of those software modules in a specific sequence and manner, to allow for the separation of parties interacting through electronic, computer readable means to the extent that they are entirely independent of each other. The invention may be used to separate parts of a single software application so that separate parts of the application may be changed totally independently from each other with no effect on the other parts of the application, or for allowing for communication between parties where parties use entirely different formats and languages for the same document that is being communicated.

This invention further relates to presentation layer technologies, data transmission formats and data storage components in a manner that allows for the totally independent change and development of any of these components without affecting any components that make use of the changed component. The invention breaks the separate parts of a communication into:

- the party that is communicating; - what is being communicated in terms of the document type;

- the format in which the document type is being communicated; and

- the transport mechanism being used to carry out the communication, and through this mechanism, in combination with the software components that define the invention, create a greater degree of independence between all of the communicating components than is currently practically possible.

Currently there are major issues relating to the ability to effectively reuse software components that contain logic for use in carrying out work on data of any format. These issues are associated with the limited possibilities for separation of the parts of an application, or two applications themselves when they are required to be connected in any way. Although it may currently be possible to reuse a component if care is taken to create the circumstances that will allow for reuse, there are no guarantees that any interface will be reusable and the degree of reuse is not total.

One of the most prevalent methods currently in use to allow for the linking of applications is through the use of Application Program Interfaces or API's. API's allow for the linking of applications, but the links generally have to be coded directly and the API's are proprietary. The API's are also extremely technology specific, requiring, for example, a different API for interaction in Java than the API used to interact in Perl and yet another API for interaction with Visual Basic 6.0. Another major problem with this method of connecting applications is that it is, and can only be, carried out on a point-to-point basis. In other words, for every connection via an API, there must be a corresponding code component that is coded to supply the correct parameters that the connection requires in exactly the format that the application being called requires. Should the parameters required by the called application change, the application calling it has to change, and every application that is calling the called application via that API has to be changed. This may involve changes to any number of software components. Another issue is that API's are a purely technical solution and, as such, address the problem of connectivity at a low level. This is a major problem with APIs in that they are only the final link to an application that you wish to interface to, but they have no capacity for allowing different formats to be handled transparently and any attempt to do that would require a lot of work outside of the API.

The essential ingredient of the problem is that there is currently no effective and convenient mechanism to allow for change in one component or application to be made without the need to simultaneously make changes to all of the applications that interact with that component. What this means is that there is currently no practical way to ignore the technical requirements of connectivity for a party that needs the connection to any specific software component to be used in providing functionality that the party may require. In other words, there is currently no realistic method for creating close to complete separation of function and the logic used to carry out the function.

This invention addresses the above shortcomings, by creating a practical mechanism for parties that require functionality to achieve interaction without having to be concerned with the technologies or any other peculiarities of the underlying software components that are to be used to provide the functionality, or with the formats of any document exchanges that may be required to achieve interactions. In an example embodiment, the invention separates any function from the logic used to achieve a function and separates the format, transport and document type used in any interaction between parties, be they humans or computer systems, by establishing an independent state between any interacting entities and using the software components that work in concert with that independent state. This state may be independent in terms of format, transport, structure and use. In an example embodiment, the present invention allows the reuse of software components and data storage components freely, both on any number and type of presentation layer, and in the processing of any number of documents in any electronic format and any number of electronic formats for the same document type. - A -

SUMMARY OF THE INVENTION

In broad terms, the present invention provides a software interface module that is adapted to accommodate the interfacing of multiple applications, software modules, or human interfaces by facilitating transfer of data between applications, software modules, or human interfaces to software components, and the components themselves to allow for the independent development, enhancement, addition or removal of applications, software modules or human interfaces on either side of the interfaces. The software also accommodates the configuration of the processing rules and the sequence in which those rules are carried out as well as when those rules are to be applied as part of the interfacing.

In particular, software is provided that consists of a collection of separate software components, and their associated configuration structures, and certain data structures used during the course of the processing of any interface, which, when acting together in the manner specified, create a complete method of establishing the separation of any number of components of a software application, or of any number of different software applications, regardless of the operating system, programming language, method or format of interfacing, location and hardware that any of these software applications or parts of software applications may require to function individually, while allowing any of these components or applications to interact effectively, by creating an independent state between them, and simultaneously, through the agency of this independent state, together with the software components that also comprise this invention, allow the said interaction to be reused or used for entirely different purposes and in any number of different ways, and allow any of the interacting software components or applications to be changed without affecting any of the software components or applications that are linked to the software component or application that is being changed, the changes being accommodated through configuration alone.

According to a first aspect of the invention there is provided a document processing system comprising: at least one incoming document controller for receiving at least one document having a format associated with the incoming document controller that the incoming document controller can identify, each of the at least one document comprising at least one data field comprising a field name and a value within the data field, which the incoming document controller is able to retrieve;

a participant identifier module for receiving the data field value retrieved by the incoming document controller and the format identifier for the document and for determining at least one first mapping identifier for the identified format; and

a mapping control module for receiving the first mapping identifier and for calling a first mapping instance corresponding to the first mapping identifier,

wherein the first mapping instance translates the data field name into an independent data field name so as to define an independent data structure comprising the independent data field name and associated value.

In an example embodiment, the document processing system further includes a memory to store the independent data structure, the independent data structure being identifiable by an independent data structure identifier and an independent data structure storage location.

In an example embodiment, the participant identifier module determines a process identifier for the identified format, with the system further comprising a process controller for receiving the process identifier, the independent data structure identifier and the independent data structure location.

In an example embodiment, the process controller can create a response document. In an example embodiment, the memory stores the response document, the response document being identifiable by a response document identifier and a response document storage location.

In an example embodiment, the document processing system further includes an activity module associated with the process controller.

In an example embodiment, the document processing system further includes an action module associated with the activity module.

In an example embodiment, the processor controller retrieves the independent data structure identifier, the independent data structure storage location, the response document identifier and the response document storage location from memory and sends this information to the action module via the activity module.

In an example embodiment, the action module comprises a second mapping instance, wherein the action module determines at least one second mapping identifier to translate the independent data field name into a client field name using the second mapping instance so as to define a client data structure comprising the client field name and associated value.

In an example embodiment, the memory stores the client data structure, the client data structure being identifiable by a client data structure identifier and a client data structure storage location.

According to a second aspect of the invention there is provided a document processing method comprising:

receiving at least one document having an identifiable format, each of the at least one document comprising at least one data field comprising a field name and a value within the data field;

identifying the format and retrieving the data field value; determining at least one first mapping identifier for the identified format;

calling a first mapping instance corresponding to the first mapping identifier; and

translating the data field name into an independent data field name so as to define an independent data structure comprising the independent data field name and associated value.

In an example embodiment, the method further includes storing the independent data structure, the independent data structure being identifiable by an independent data structure identifier and an independent data structure storage location.

In an example embodiment, the method further includes determining a process identifier for the identified format.

In an example embodiment, the method further includes creating a response document.

In an example embodiment, the method includes storing the response document, the response document being identifiable by a response document identifier and a response document storage location.

In an example embodiment, the method further includes retrieving the independent data structure identifier, the independent data structure storage location, the response document identifier and the response document storage location and sending this information to an action module.

In an example embodiment, the method includes:

determining at least one second mapping identifier; and translating the independent data field name into a client field name using a second mapping instance associated with the second mapping identifier so as to define a client data structure comprising the client field name and associated value.

In an example embodiment, the method includes storing the client data structure, the client data structure being identifiable by a client data structure identifier and a client data structure storage location.

In an example embodiment, the method includes creating a client document comprising the client field name.

In an example embodiment, the method includes populating at least one field required by an external component that the action module is configured to call using the client data structure.

In an example embodiment, the action module receives a response from the external component and inserts the response into the response document.

BRIEF DESCRIPTION OF THE DRAWINGS

The present invention is illustrated by way of example and not limitation in the figures of the accompanying drawings, in which:

Figure 1 shows a schematic diagram of a system, according to an example embodiment, to process a document, wherein the key for this diagram is as follows:

A: Incoming document

B: Incoming document interface

C: Participant identifier

D: Mapping controller

E: Mapping instance F: Independent middle state

G: Process component

H: Activity component

I: Action mapping controller

K: Response document

L: Action mapping

M: A destination format

N: A destination format

O: Software component accessed

Figure 2 shows a flow chart of a method, according to an example embodiment, to process a document; and

Figure 3 shows a diagrammatic representation of machine in the example form of a computer system within which a set of instructions, for causing the machine to perform any one or more of the methodologies discussed herein, may be executed.

DESCRIPTION OF EMBODIMENTS

The present invention will be described with reference to Figure 1 , and with reference to a worked example.

As background to the worked example, a document of the type Personal Details is being used. The Personal Details document type contains the following data fields: the first name, the initials and the last name of a person, as well as an account number for the person.

For the sake of illustration, the Personal Details document is to be received in two different formats, although it is to be noted that the two formats chosen for the purposes of this worked example are for demonstration only, with the invention being able to receive and process documents in any meaningful and understandable electronic format. The first format in which the Personal Details document is to be received is Extensible Mark-up Language (XML), in which the element names are:

AccountNumber FirstName Initials LastName

In a genuine document sent in the XML format, each of the above field names would contain data with some meaning. In this example, they would be:

<AccountNumber>890900</AccountNumber> <FirstName>William</FirstName> <lnitials>B</lnitials> <LastName>Tell</LastName>

The second format in which the Personal Details document is to be received is Comma Separated Values (CSV). In CSV there are no field names, the identity of a field is established by its position relative to the start of a record by counting the number of commas from the first field. For the purposes of this worked example, the fields will be assumed to have been sent in the following order:

First Name, Initials, Last Name.Account Number

In a genuine document, the fields would be populated with actual values with some meaning. In this example, they would be:

William, B,Tell,890900

Thus, for this worked example, the document type is to be processed through the invention in two ways. In other words, the same document type, namely Personal Details, is received in two formats, namely Extensible Mark-up Language (XML) and Comma Separated Values (CSV).

The worked example will now be described with reference to the attached drawing, in order to relate the processing carried out on the Personal Details document type to the specific component of the invention responsible for any specific processing.

Thus, the Personal Details document type is sent by any party that needs to send a Personal Details document to a location that is specified for the format in which the document is sent. For the purposes of this example, the two documents of the type Personal Details are sent in the XML and CSV formats, with the subsequent processing of these two documents now being explained through the medium of this worked example.

Thus, in an example embodiment, Component A in the figure represents an incoming document of the Personal Details document type.

Any one instance of an incoming document controller component B of the invention is designed to retrieve data of a specific format. This component may be configured to examine the locations in which these documents may be placed either at specified time intervals, or by being manually caused to examine those locations, or by being automatically triggered by some event that then triggers any instance or instances of component B.

Significantly, component B does not check the content of the document beyond certain locations defined as containing significant information for the purpose of continuing the processing of the document. In other words, this component does not differentiate between document types, but rather only the format of the documents that it retrieves. This is an important aspect of creating independence; the absence of needing to know what is being processed is significant since this allows an instance of component B to process any document type in the format that that specific instance is intended to process regardless of content. Thus, in this worked example, two instances of component B would each retrieve an instance of the Personal Details document A.

Incoming document controller component B is configured to examine certain locations within any document of the format that it is designed to retrieve for information that will enable it to pass the necessary information to a participant identifier component C to allow component C to pass back to component B the information necessary to establish which instance E of the mapping controller component D should be used to map the incoming Personal Details document A to an Independent Middle State Aggregate document F by the process of mapping individual data elements or blocks of information to the appropriate corresponding data elements or blocks of information in the independent middle state aggregate document, as well as which process instance G should be used to process the document type that was received.

The process instance G processes the document by activating, through the activity component/s H that make up the process by being associated with a process by configuration action components I that are associated with individual data elements and/or blocks of information in the independent middle state aggregate document F.

Thus, and turning now to the worked example, an instance of component B will retrieve the value that relates to the field Account Number in the document type Personal Details in each of the formats that the document type arrives from the instances of the document type.

In other words, the instance of component B that is designed to retrieve documents that arrive in XML format, will have been configured to retrieve the value contained in the element "AccountNumber" (i.e. 890900) and pass this value to component C. Similarly, the instance of component B that is designed to retrieve documents in CSV format, will have been configured to retrieve the value contained in the fourth field of the CSV file (i.e. 890900) and pass this value to component C. In addition to the actual value being sent to component C, component B also sends an identifier for identifying the instance of component B that retrieved document A. Thus, in this case, the following two sets of information would be sent to component C:

XML format: Account Number: 890900 component B identifier: BXML

CSV format: Account Number: 890900 component B identifier: BCSV

Thereafter, the component C uses the "Account Number" value of "890900" and the identifier, in this case "BXML" as well as the "Account Number" value of "890900" and the identifier "BCSV" to return the identifiers of the appropriate mapping and process instances E and G, respectively, to be used to process the incoming documents A.

For the purposes of this example, we can assume that participant identifier component C may return the following mapping and processes instances identifiers:

For the XML version of component B:

Mapping identifier: Xa1234M Process identifier: CCO897PF

For the CSV version of component B:

Mapping identifier: Xb4321 M Process identifier: CCO897PF

Again, as indicated above, the exact structure of the identifiers may differ in any given implementation of the invention. In addition, there may be more than one mapping identifier and more than one process identifier retrieved, as the invention does not limit the number of mappings that may be carried out from one document A and there is no limit on the number of processes that may be carried out on any one document A.

Significantly, it is important to appreciate the separation of the format of a document from the document type, and therefore the processing that is carried out on any specific document type. In other words, although the two instances of the document type Personal Details were received in different formats, they are, once mapped to the appropriate Independent Middle State aggregate document F, processed using the same process instance G. This is an important point, as it demonstrates the invention's ability to separate the processing of a document type from the format in which it is received through configuration of the mapping alone.

Once component B has retrieved the identifiers above, it passes the mapping identifiers to component D, which is a mapping control component. This component, in turn, calls the appropriate mapping instance E that is identified by the mapping identifier passed to it.

Thus, in the present example, component B would call component D, passing the two identifiers of instances of mapping components E, namely Xa1234M and Xb4321M.

Component D, upon receipt of the two identifiers sent by component B, will, in turn, call the mapping instances E identified by each identifier.

Each mapping instance E that is called translates the incoming Personal Details document A from the format that it is designed to translate to the independent middle state aggregate document F that it is configured to map that specific document type to.

Once the mapping instance E has carried out its translation, it creates and stores an instance of the independent middle state aggregate document (IMSAD) F that it translated the incoming Personal Details document A to in a location that it is configured to store the document.

Where there is more than one independent middle state aggregate document that one specific format of an incoming document A is to be translated to, there would be multiple mapping identifiers returned from the participant component C. The mapping controller D would, in turn, call multiple mapping instances E.

For the purposes of this example, the following mapping may be assumed to have taken place:

The mapping component E that is configured to translate the XML format version of the document type Personal Details, which is identified by the unique identifier Xa1234M would carry out the following translation and store the resultant IMSAD document:

XML file element Value IMSAD field Value name name

AccountNumber 890900 AcctNo 890900

FirstName William ForeName William

Initials B I nits B

LastName Tell SurName Tell

UniquelD IMSAD1

The mapping component E that is configured to translate the CSV format version of the document type Personal Details, which is identified by the unique identifier Xb4321 M would carry out the following translation and store the resultant IMSAD document: CSV file field Value IMSAD field Value number name

1 William ForeName William

2 B I nits B

3 Tell SurName Tell

890900 AcctNo 890900

UniquelD IMSAD2

As indicated above, it is important to appreciate how the invention separates the format that any specific document type is received in from the processing that is to be carried out on the specific document type. Thus, after translating both the XML and CSV formats of the same Personal Details document type, the documents above, each identified by their respective values in the "UniquelD" field name in the IMSAD, are now two instances of exactly the same document in exactly the same, independent format, so that the two instances are at this point identical. At this point the difference of format between the instances of the document has been removed.

This translation through mapping means that from this point on, the two documents may be processed by the same process, with there now being no requirement for any differences in the components that do any further processing on the two instances of the Personal Details document that now exist as IMSAD instances.

Note that, while in this example, we have focussed on the same document type being received from the same party in differing formats, there are other valid situations. The same document may be received in the same format or different formats from different parties, where it may be appropriate to create the same independent middle state document but to use different processes to process the documents for any reason that may require this, in this case we are separating document type and format and document type and processing, allowing different processing to be configured for different parties that supply the same document. This is all achieved through configuration.

Once a mapping instance E has translated and stored an instance of the independent middle state aggregate document that it was configured to create and store, the mapping instance E will notify the mapping controller D that it is finished and, will return the unique identifier of the independent middle state aggregate document that it created and stored in the location that it was configured to store the IMSAD document back to the mapping controller D.

Thus, for the purposes of this example, the two mapping instances identified by the unique identifiers "Xa1234M" and "Xb4321M" would return the unique identifiers "IMSAD1" and "IMSAD2" respectively.

Upon receipt of the notification that a mapping instance is finished with its task and upon receipt of the identifier of the IMSAD document that was created and stored, the mapping controller D will notify component B that it has completed mapping, and provide component B with the unique identifier of the IMSAD F that was created and stored as well as the location of the IMSAD document. Thus the location of IMSAD documents may be changed through configuration and any changes require no changes to any of the internal components of the invention as they discover the location at the time that they are activated.

For the purposes of this example, we shall assume that the XML mapping instance completed its translation first and returned the unique identifier of the IMSAD it created and stored "IMSAD1" to the mapping controller D at the time it notified the mapping controller D that it was finished along with the location. For the purposes of this example, we will use a location that is unrealistic, but will serve to show the principle, namely 7/Server1/Loc/" as the location. The mapping controller D then returned the unique identifier "IMSAD1" to the instance of component B that called it, this being the unique identifier of the IMSAD created by the mapping instance E, and passing the location of that instance to it as well.

As indicated above, from this point on, since the two instances of the document type Personal Details are identical, the example will focus on the processing of one instance of the document Personal Details since the processing of the other instance may be exactly the same in all respects. This is a significant feature of the present invention, in that, in an example embodiment, the processing from this point on may be exactly the same in every possible respect. In other words, at this point, there is no difference between the documents.

Component B, upon being notified by the mapping controller D that it has completed a mapping instance E, will call the process instance G identified by the identifier that it retrieved from component C as well as the unique identifier of the IMSAD F that was sent to component B by the mapping controller D. Thus, for the purposes of this example, component B would receive the following:

IMSAD unique identifier: "IMSAD1" IMSAD Location: 7/Server1/Loc/"

For the purposes of this example, the instance of component B would have retrieved the following process identifier from C when it requested the mapping and process instance identifiers that corresponded to the document type and format it was configured and designed to process, namely process instance identifier "CCO897PF".

The process controller G, will, upon being called by component B, activate a process instance identified by the identifier passed to the process controller G by component B, and simultaneously pass to the process instance the unique identifier and the location of the IMSAD document that it received from the mapping controller D. Thus, for the purposes of this example, the process controller G would call the process instance identified by the unique identifier "CC0897PF" and pass the IMSAD unique identifier "IMSAD1" and the location 7/Server1/Loc/" to the process instance H.

The process instance may, upon being called, create a response document instance K and create a unique identifier for the response document in the most appropriate manner. A response document may be created and stored in a repository of some kind and may, as a result, have a unique identifier generated by the repository at the time that the response document instance K was stored, or it may be created in some other manner and have an identifier of the specific response document instance K created or generated in a manner appropriate to the method being used. In any event, the invention specifies that a response document or a structure that is designed and intended to carry responses is created and is identifiable in some way; the exact method in which this is done is not prescribed.

For the purposes of this example, the following response document instance identifier is created:

Response document identifier: "RD001" Response document location: 7/Server2/RDLoc/"

The process instance will retrieve the identifiers of the first activity instance H, or all of the activity instances contained in its configuration, and call the appropriate activity instance/s H and will pass the unique identifier of the IMSAD F, the location of the IMSAD F, and the unique identifier and location of the response document instance K to the activity instance H at the time that the activity instance is called.

It must be noted that a process instance may contain any number of activity instances H, with the activity instance/s H being called either sequentially or simultaneously. The invention allows for both methods, with the most appropriate being be used at any time.

For the purposes of this example the following would be passed to the process instance activated by the process controller G:

Response document identifier: "RD001" Response document location : 7/Server2/RDLoc/"

Any activity instance H that is called by the process instance, checks its configuration and identifies the action instances I that it, in turn, must call.

The activity instance H then calls the action instances I, which it is configured to call, passing the unique identifier and the location of the IMSAD F that the action instance I is to retrieve information from, and the unique identifier and the location of the response document instance K that it was passed by the process instance, as it is configured to do.

It must be noted that an activity instance H may contain any number of action instances I, with the action instances being called either sequentially or simultaneously. As indicated above, the invention allows for both methods, with the most appropriate method may be used at any particular time.

It must further be noted that the invention allows for the configuration of dependencies between action instances I to be entered to allow for the activity instance H that contains a collection of action instances I to call any number of action instances simultaneously and to avoid causing conflicts while doing this by checking for dependencies between action instances.

The invention further allows for the passing of data between actions where an earlier action in a sequence returns a response that is required by an action instance I called by the same activity instance H, but which is later in the sequence of action instances I configured in the activity instance H. This is a dependency with information being passed. There are, however, also dependencies that have no information passed between action instances I within the invention, but are dependencies of sequence or time that may occur when two external components have dependencies between themselves but do not use information directly. These external components must be called in a specific sequence but do not need information to be passed between them through the action instances I that call them. An example of this type of dependency might be where a calculation is carried out by a first external component that is called by an action instance I in an activity where a second external component requires the calculation that was carried out by the first external component to have been carried out as it makes use of the result of the calculation, but it does not require the actual result to be passed from the first external component to the second external component through any action component, rather, the result may be placed in a location outside of the invention where the second external component can retrieve it for its own use. It is important to note that the interactions of these two external components, or indeed any external components are outside of the scope of this invention, apart from the sequence in which they are called, which is configured as a dependency within the activity component H of the invention and, where any parameters or results are passed between the action instances associated with those external components. There is no need for the action instances within the invention to have any shared knowledge of the format, technology, or anything else about any external components that are linked in this manner. The two external components may have been developed using entirely different technologies, be resident in different geographical locations and be called or activated in entirely different manners. The action components responsible for each external component act independently and, in another instance, either of the components linked through the action components may operate to carry out the same logic without being linked in any way by action components. The components themselves are still independent from the perspective of the invention; the link is incidental.

Thus, for the purposes of this example the action instance I that is called by the activity instance H is passed the following: IMSAD instance identifier: "IMSAD1" IMSAD Location: 7/Serveιi/Loc/" Response document identifier: "RD001" Response document location : 7/Server2/RDLoc/"

An action instance I₁ upon being called by the activity instance H and passed the unique identifier and the location of the IMSAD F and the unique identifier and the location of the response document K, checks in its configuration to retrieve the unique identifier for a mapping instance N to use to translate the appropriate parts of the IMSAD document to an understandable and appropriate format for an external component that it is configured to call, or the external file that it is configured to create, and then calls the mapping controller N with the unique identifier of the mapping instance that it requires. In an example embodiment, an action mapping controller L may be used to provide the action instance I with the unique identifiers for the mapping instances N.

For the purposes of this example, let us assume that the action instance I uses the following mapping to retrieve and translate information from the IMSAD to the parameters required by the external component it is configured to communicate with:

Field name in Value in Field name Value to be IMSAD IMSAD field required by placed in field external for external component component

SurName Tell Last Tell

AcctNo 890900 AccNo 890900

Once the mapping instance N has translated the parts of the IMSAD and created a translated version of the parts of the IMSAD that are to be communicated, it returns the unique identifier of the translated document as well as the location of that document to the action instance I. The action instance I uses the translated document to populate any parameters that are required by an external software component O that it is configured to call, or uses the translated document to create any document M or file N in any format that it is configured to create and then carries out the call, passing the parameters, or creating the document M or file N it is configured to create and places it in a location that it is configured to place the file.

Once an action instance I has completed the task that it is configured to carry out, it may receive a response from the external component O that it called. The action instance I₁ upon receiving a response from an external component, will place that response into the response document instance identified by the unique identifier of the response document instance that it was sent by the activity instance.

For the purposes of this example we shall assume that the external component O that was called by the action component instance I is designed to check whether the account number "890900" is linked to anyone with the last name "Tell".

Let us further assume that this is the case, although both negative and positive responses would have been handled in the same manner. Based on the above, let us assume that the external component O, to which the action instance I is linked, returns the value of, for example, "True". Clearly, the value/term "True" has been used primarily for convenience, with the component being able to return a numeric value, or any other term that it specifies - the action instance I will be configured to handle any specific responses that are returned. In other words, the actual content and format of the response are not limited in the invention, and are accommodated by configuration.

For the purposes of this example, we may assume that the returned value "True" is placed into the response document K at the appropriate place. Any action instance I, which has carried out the task that it was configured to carry out, or, upon failure for any reason of a technical nature, will respond to the activity instance H that called it to inform that activity instance that it is either complete, or has failed.

For the purposes of this example, the action instance I notifies the activity instance H that called it that it has successfully completed its task.

Any activity instance H that has completed all of the action instances I that it was configured to complete, will notify the process instance G that called it that it has completed all of the actions that it was configured to carry out, or, upon failure, will inform the process instance G that called it, that it has failed.

For the purposes of this example, the activity instance H notifies the process instance G that called it that it has successfully completed its task.

Once the process instance G was completed successfully, it will return the unique identifier and the location of the response document K that it created and stored, and which was populated by the action instances I, that were configured to populate it.

The process instance G will notify the incoming document controller B that called it that it has successfully completed all of the activities it was configured to complete and will pass the unique identifier and the location of the response document K that was created to the instance of component B that called it at that time.

For the purposes of this example, the calling instance of component B will be sent the following:

Response document identifier: "RD001" Response document location : 7/Server2/RDLoc/" The incoming document controller B will, upon receipt of the notification of successful completion of a process instance G, will, using the unique identifier and location of the response document K that was passed to it by the process controller G, retrieve the response document instance K, and examine the response document for information that it may then pass on, or act on in some way.

For the sake of completeness, it would be useful to highlight the differences between a document format and a document type, as follows:

• All documents in a specific format are retrieved by an incoming document retrieval component that is configured to retrieve many different documents of one specific format. At this point the document type is irrelevant, and only the format is relevant.

• The incoming document retrieval component has no need to know what type of documents it is retrieving. This component is only designed and configured to retrieve a specific data format.

• An incoming document retrieval component may retrieve data of the format that it is designed and configured to retrieve where the data do not constitute a true document, but are parameters, or data elements that are being transmitted as values through the invention for some purpose.

• The term document is used to describe all cohesive and meaningfully related collections of data that are sent into the invention as a convenient term since all of these collections of data are handled in the same way. Using one term makes meaningful description of the manipulations carried out on those collections of data easier and more understandable.

• Any documents of a specific type retrieved by an incoming document retrieval component, regardless of the format in which the document arrived, are translated to instances of the same independent middle state aggregate document, this removes the need for any knowledge of the format that the document was sent in by any party making use of the document in any process.

• These manipulations allow the same document type from the same, or any number of different sources, the number of sources being irrelevant, to be sent into the invention in any number of different formats and to be processed in the same way with no differences in the components carrying out the processing, since to those components there is no knowledge of the format in which the document was received.

• These manipulations also allow the same document type from any number of different sources, the number of sources being irrelevant, to be sent into the invention in any number of different formats and to be processed in different ways where appropriate, through the identification of the participant from whom any document type was received, and/or to whom any document type is to be sent with no differences in the components carrying out the processing except where there are differences in the processing that is required, since to those components there is no knowledge of the format in which the document was received, nor the type of document that was received.

• An extremely important point with regard to the two points immediately above is that in the cases mentioned above, the bulk of the components that do the actual processing (these would be the action components I in the diagram) would be reused on both processes, this is another important aspect of the invention.

Turning now to Figure 2, in an example embodiment, a method 200 to process an incoming document comprises receiving at least one document having an identifiable format, each of the at least one document comprising at least one data field comprising a field name and a value within the data field, as indicated by block 202. The method 200 further comprises identifying the format and retrieving the data field value, as indicated by block 204, and then determining at least one first mapping identifier for the identified format, as indicated by block 206. Finally, the method 200 comprises calling a first mapping instance corresponding to the first mapping identifier, as indicated by block 208, and translating the data field name into an independent data field name so as to define an independent data structure comprising the independent data field name and associated value, as indicated by block 210. In an example embodiment, the method 200 further includes storing the independent data structure, as indicated by block 212. The independent data structure may be identifiable by an independent data structure identifier and an independent data structure storage location.

In an example embodiment, the method 200 further includes determining a process identifier for the identified format, as indicated by block 214.

In an example embodiment, the method 200 further includes creating a response document, as indicated by block 216.

In an example embodiment, the method 200 includes storing the response document, as indicated by block 218. The response document may be identifiable by a response document identifier and a response document storage location.

In an example embodiment, the method 200 further includes retrieving the independent data structure identifier, the independent data structure storage location, the response document identifier and the response document storage location and sending this information to an action module, as indicated by block 220.

In an example embodiment, the method 200 includes determining at least one second mapping identifier, as indicated by block 222, and translating the independent data field name into a client field name using a second mapping instance associated with the second mapping identifier so as to define a client data structure comprising the client field name and associated value, as indicated by block 224.

In an example embodiment, the method 200 includes storing the client data structure, as indicated by block 226. The client data structure may be identifiable by a client data structure identifier and a client data structure storage location. In an example embodiment, the method 200 includes creating a client document comprising the client field name, as indicated by block 228.

In an example embodiment, the method 200 includes populating at least one field required by an external component that the action module is configured to call using the client data structure, as indicated by block 230.

In an example embodiment, the action module H receives a response from the external component and inserts the response into the response document, as indicated by block 232.

The essential features that make the software interface module different from existing software:

1. The software interface module allows for the reuse of interfaces across disparate systems, in that the software interface module removes dependencies from the use of interfaces by allowing for the unlimited reuse of interfaces once created, with this reuse being achieved by configuration alone.

2. Reuse of any interfaces is possible without any limitations based on the actual component or application being reused, with the actual nature of the reused component being unknown at the time of reuse, once a software component is linked into the invention, it is reusable without reference to its underlying technical makeup.

3. The software interface module separates all connected components by defining an independent middle state that removes dependencies between the actual components being integrated and making each able to be changed or indeed replaced or removed without affecting the other.

4. The software interface module allows for the reuse of interfaces to be configured dynamically, with there being no impact on the applications. 5. The sequence in which interfaces are used is able to be changed without affecting the interfacing applications as the interface and the components are entirely separated. The sequence in which components are used is independent of the components themselves. Again, this feature too is achieved by configuration alone.

6. The software interface module operates on components in terms of functions i.e. an interface is only visible in terms of its name and what it does from a functionality perspective, and it is reusable in those terms. How any component carries out any function is entirely irrelevant and, at the time that the component is reused through configuration, any component is entirely invisible to the person reusing the component.

7. The software interface module ensures that there is no requirement or assumption that any specific type of interface is used to connect to the software interface module, or that the software interface module will produce any specific type of output.

8. The software interface module addresses the problems of reuse and the associated requirement for technical knowledge of any software components being reused through the invention by making any component visible to a person wishing to make use of it in terms of what the component does through descriptions that are defined in a manner that is clear and has meaning to the prospective person or people that will reuse the component and that can be changed by the person or people that are going to make use of the component in such a way that is meaningful to that person or people.

9. The software interface module also simplifies access to any combination of software applications or components of any size or complexity by exposing the collection of those components, applications, or both as a service; the details of the components and applications that are used in processing the document are never exposed to the people submitting documents of any type, they only submit a document and it is processed as needed by the recipient without the submitting party needing any knowledge of what is being carried out on or with the document that they submitted. An example may be a party that submits a "home loan application" document type; that is all that that party does in a format that is convenient for that party, how it is processed, or what components or data formats are used during the processing of that document are irrelevant.

10. The independent nature of the software interface module allows either interfaces to be changed independently of the other.

Figure 3 shows a diagrammatic representation of machine in the example form of a computer system 300 within which a set of instructions, for causing the machine to perform any one or more of the methodologies discussed herein, may be executed. In alternative embodiments, the machine operates as a standalone device or may be connected (e.g., networked) to other machines. In a networked deployment, the machine may operate in the capacity of a server or a client machine in server-client network environment, or as a peer machine in a peer-to-peer (or distributed) network environment. The machine may be a personal computer (PC), a tablet PC, a set-top box (STB), a Personal Digital Assistant (PDA), a cellular telephone, a web appliance, a network router, switch or bridge, or any machine capable of executing a set of instructions (sequential or otherwise) that specify actions to be taken by that machine. Further, while only a single machine is illustrated, the term "machine" shall also be taken to include any collection of machines that individually or jointly execute a set (or multiple sets) of instructions to perform any one or more of the methodologies discussed herein.

The example computer system 300 includes a processor 302 (e.g., a central processing unit (CPU), a graphics processing unit (GPU) or both), a main memory 304 and a static memory 306, which communicate with each other via a bus 308. The computer system 300 may further include a video display unit 310 (e.g., a liquid crystal display (LCD) or a cathode ray tube (CRT)). The computer system 300 also includes an alphanumeric input device 312 (e.g., a keyboard), a user interface (Ul) navigation device 314 (e.g., a mouse), a disk drive unit 316, a signal generation device 318 (e.g., a speaker) and a network interface device 320.

The disk drive unit 316 includes a machine-readable medium 322 on which is stored one or more sets of instructions and data structures (e.g., software 324) embodying or utilized by any one or more of the methodologies or functions described herein. The software 324 may also reside, completely or at least partially, within the main memory 304 and/or within the processor 302 during execution thereof by the computer system 300, the main memory 304 and the processor 302 also constituting machine-readable media.

The software 324 may further be transmitted or received over a network 326 via the network interface device 320 utilizing any one of a number of well-known transfer protocols (e.g., HTTP).

While the machine-readable medium 322 is shown in an example embodiment to be a single medium, the term "machine-readable medium" should be taken to include a single medium or multiple media (e.g., a centralized or distributed database, and/or associated caches and servers) that store the one or more sets of instructions. The term "machine-readable medium" shall also be taken to include any medium that is capable of storing, encoding or carrying a set of instructions for execution by the machine and that cause the machine to perform any one or more of the methodologies of the present invention, or that is capable of storing, encoding or carrying data structures utilized by or associated with such a set of instructions. The term "machine-readable medium" shall accordingly be taken to include, but not be limited to, solid-state memories, optical and magnetic media, and carrier wave signals. Although an embodiment of the present invention has been described with reference to specific example embodiments, it will be evident that various modifications and changes may be made to these embodiments without departing from the broader spirit and scope of the invention. Accordingly, the specification and drawings are to be regarded in an illustrative rather than a restrictive sense.

Claims

1. A document processing system comprises:

at least one incoming document controller for receiving at least one document having a format associated with the incoming document controller that the incoming document controller can identify, each of the at least one document comprising at least one data field comprising a field name and a value within the data field, which the incoming document controller is able to retrieve;

2. A document processing system according to claim 1 , which further includes a memory to store the independent data structure, the independent data structure being identifiable by an independent data structure identifier and an independent data structure storage location.

3. A document processing system according to claim 2, wherein the participant identifier module determines a process identifier for the identified format, with the system further comprising a process controller for receiving the process identifier, the independent data structure identifier and the independent data structure location.

4. A document processing system according to claim 3, wherein the process controller can create a response document.

5. A document processing system according to claim 4, wherein the memory stores the response document, the response document being identifiable by a response document identifier and a response document storage location.

6. A document processing system according to claim 5, which further includes an activity module associated with the process controller.

7. A document processing system according to claim 6, which further includes an action module associated with the activity module.

8. A document processing system according to claim 7, wherein the processor controller retrieves the independent data structure identifier, the independent data structure storage location, the response document identifier and the response document storage location from memory and sends this information to the action module via the activity module.

9. A document processing system according to claim 8, wherein the action module comprises a second mapping instance, wherein the action module determines at least one second mapping identifier to translate the independent data field name into a client field name using the second mapping instance so as to define a client data structure comprising the client field name and associated value.

10. A document processing system according to claim 9, wherein the memory stores the client data structure, the client data structure being identifiable by a client data structure identifier and a client data structure storage location.

11. A document processing method comprises:

identifying the format and retrieving the data field value;

determining at least one first mapping identifier for the identified format;

12. A document processing method according to claim 11 , which further includes storing the independent data structure, the independent data structure being identifiable by an independent data structure identifier and an independent data structure storage location.

13. A document processing method according to claim 12, which further includes determining a process identifier for the identified format.

14. A document processing method according to claim 13, which includes creating a response document.

15. A document processing method according to claim 14, which includes storing the response document, the response document being identifiable by a response document identifier and a response document storage location.

16. A document processing method according to claim 15, which further includes retrieving the independent data structure identifier, the independent data structure storage location, the response document identifier and the response document storage location and sending this information to an action module.

17. A document processing method according to claim 16, which includes:

determining at least one second mapping identifier; and

translating the independent data field name into a client field name using a second mapping instance associated with the second mapping identifier so as to define a client data structure comprising the client field name and associated value.

18. A document processing method according to claim 17, which includes storing the client data structure, the client data structure being identifiable by a client data structure identifier and a client data structure storage location.

19. A document processing method according to claim 18, which includes creating a client document comprising the client field name.

20. A document processing method according to claim 18, which includes populating at least one field required by an external component that the action module is configured to call using the client data structure.

21. A document processing method according to claim 20, wherein the action module receives a response from the external component and inserts the response into the response document.

22. A document processing system comprising:

memory to store at least one mapping identifier corresponding to a document format; and

a processor to:

receive at least one document having an identifiable format, each of the at least one document comprising at least one data field comprising a field name and a value within the data field;

identify the format and retrieving the data field value;

extract the at least one first mapping identifier from memory for the identified format;

call a first mapping instance corresponding to the first mapping identifier; and

translate the data field name into an independent data field name so as to define an independent data structure comprising the independent data field name and associated value.

23. A document processing system according to claim 22, wherein the processor is configured to store the independent data structure in memory, the independent data structure being identifiable by an independent data structure identifier and an independent data structure storage location.

24. A document processing system according to claim 23, wherein the processor is configured to determine a process identifier for the identified format.

25. A document processing system according to claim 24, wherein the processor is configured to create a response document.

26. A document processing system according to ciaim 25, wherein the processor is configured to store the response document in memory, the response document being identifiable by a response document identifier and a response document storage location.

27. A document processing system according to claim 26, wherein the processor is configured to retrieve the independent data structure identifier, the independent data structure storage location, the response document identifier and the response document storage location and send this information to an action module.

28. A document processing system according to claim 27, wherein the processor is configured to:

determine at least one second mapping identifier; and

translate the independent data field name into a client field name using a second mapping instance associated with the second mapping identifier so as to define a client data structure comprising the client field name and associated value.

29. A document processing system according to claim 28, wherein the processor is configured to store the client data structure in memory, the client data structure being identifiable by a client data structure identifier and a client data structure storage location.

30. A computer-readable medium embodying instructions to process a document, the instructions when executed by a machine cause the machine to: receive at least one document having an identifiable format, each of the at least one document comprising at least one data field comprising a field name and a value within the data field;

identify the format and retrieving the data field value;

determine at least one first mapping identifier for the identified format;

31. A document processing system

means for receiving at least one document having an identifiable format, each of the at least one document comprising at least one data field comprising a field name and a value within the data field;

means for identifying the format and retrieving the data field value;

means for determining at least one first mapping identifier for the identified format;

means for calling a first mapping instance corresponding to the first mapping identifier; and means for translating the data field name into an independent data field name so as to define an independent data structure comprising the independent data field name and associated value.