GB2341953A

GB2341953A - Communication between two computer programs via a generic interface

Info

Publication number: GB2341953A
Application number: GB9820971A
Authority: GB
Inventors: John Colgrave
Original assignee: International Business Machines Corp
Current assignee: International Business Machines Corp
Priority date: 1998-09-28
Filing date: 1998-09-28
Publication date: 2000-03-29
Anticipated expiration: 2018-09-28
Also published as: GB2341953B; GB9820971D0

Abstract

A data processing apparatus, providing a platform for running a called software program 212 to which a calling software program 201 can make a call, comprises: receiving means 212a for receiving a call from the calling software program, the call including a pointer to a data mapping object 202 which has an input state having data in a predetermined format; and means for calling the data mapping object and retrieving the data mapping object's input state in the predetermined format; wherein the data mapping object maps data provided by the calling program from a second format used by the calling program, which is different from the predetermined format, into the predetermined format, as the data mapping object's input state.

Description

2341953 DATA PROCESSING APPARATUS SUPPORTING COWUNICATION BETWEEN A FIRST

PROGRAM AND A SECOND PROGRAM VIA A GENERIC INTERFACE

Field of the Invention

The present invention relates to data processing systems, and more specifically to data processing systems where a first software program communicates with a second program by sending a request to the second program via a predefined interface.

Background of the Invention

In the data processing field, it is very common to have one software program communicate with another program via a predefined interface, which defines the way in which the two programs will communicate with each other.

For example, it is very common to provide an intermediary program through which a first software program can communicate with a second software program. A f irst program sends a request to the intermediary program which processes the request and passes it along to the second program, with which the first program wants to communicate with. Also, the first program may send a request to the intermediary program in order to access a data store, or for some other purpose. The intermediary program is used in order to control and coordinate such communications (e.g., to prevent conflicting accesses to the same data store at the same time, to perform data format conversions, to implement security measures etc.) The first program usually sends a request to the intermediary software program via an application programming interface (API) on the front end of the intermediary software program. The intermediary software program also uses its API to provide outputs back to the requesting software programs. This requires that the first program knows how to communicate with the API of the intermediary program and that the intermediary program knows how to communicate with the first program.

when a new type of first program is to be used to access an API of an intermediary program, some type of conversion must take place so that the first program and the API of the intermediary program will understand each other.

For example, as shown in Fig. 1, if the first program is a Java program 101 and the intermediary program is a CICS program 112 (CICS is a trademark of the IBM Corp.), the CICS program 112 will not normally 2 understand requests sent by the Java program 101 ("Javan is a trademark of Sun Microsystems Inc.). Thus, certain software elements can be added in order to allow the Java program 101 and the CICS program 112 to understand each other.

in this example of Fig. 1, the Java program 101 and the CICS program 112 are running in the same process of a data processing unit (which could be a personal computer, midrange computer or a large mainframe computer). CICS is a well-known piece of software called a transaction monitor, which has been around for many years. A Java program, which is a fairly recent development in the software world, is an example of a program which supports an object-criented programming (00P) capability. OOP is a well-known programming technique in which the functionality of the program is separated into units and each unit is called an "object". Further, the data upon which the functionality of an object operates is also assigned solely to the object. Since CICS program 112 is a well established program and Java program 101 is fairly new, these two types of programs have not usually been able to communicate with each other and if they are to be made to communicate, a conversion is necessary.

one possible conversion would be to add a Java Byte Array API 112a onto the CICS product 112 in order to allow the CICS product 112 to understand the Java concept of a byte array. However, if this software element 112a were the only element to be added in making the conversion, the Java program 101 would be left with too much data mapping work in order to convert user data into and from the byte array format.

Accordingly, in order to make the job of the Java program 101 easier, another possible conversion could be done, as shown in Fig. 1.

Firstly, the Java byte array API 112a, which was discussed above, would need to be added on top of the existing CICS API. Secondly, an additional software element 111 called a Visual Age for Java CICS API 111 ("Visual Age" is a trademark of the IBM Corp.) would need to be added, which is part of IBM's visual Age for Java application development tool.

Finally, a software element 102 (called a Visual Age for Java object), which is generated by using the visual Age for Java application development tool 12, would need to be provided. The addition of these software elements allows the CICS program 112 to understand calls sent by the Java program 101. These software elements also allow CICS program 112 to send replies back to the Java program 101.

3 In Fig. 1, the Java program 101 may want to communicate with the intermediary program (i.e., CICS program 112) so that the Java program 101 can send a request to a second program 114 through the CICS program 112. Alternatively, the Java program 101 may want to communicate with the CICS program 112 so that the Java program 101 can access a data store 113 which is being coordinated by the CICS program 112.

It should be noted that the software elements shown in Fig. 1 need not be all running in the same process on the same machine as described.

Instead, some of the elements may be running on separate machines which are connected to each other via a network (local area network, wide area network, the Internet, etc.). Also, the software elements shown could be running in separate processes on the same machine.

is An application development (AD) tool 12, such as IBM's Visual Age for Java, is usually used by a programmer to generate software code such as the vAi object 102. in constructing such software code, the AD tool --- 12 receives an input from either the second program 114 or the data store 113 so that the AD tool 12 will know the data structure (e.g., program 114's representation of the programming language construct, which could be, for example. a COBOL copybook) that is to be used, such information is then used to create the object 102.

The VAJ CICS API 111 in Fig. 1 is part of the Visual Age for Java AD tool and is thus specific to one particular AD tool 12 (the VAJ AD tool in the example). Likewise, the object 102 is specific to that same AD tool. This greatly limits the openness of the overall architecture.

That is, if another AD tool were to be supported, a separate API 111 and mapping object 102 would have to be provided.

Also, with the potential solution of Fig. 1, the VAJ CICS API 111 is specific to the CICS product. Thus, if an AD tool developer chooses to support a different intermediary program product (e.g., a database product or a messaging/queuing product) and provides an appropriate API 111 specific to that intermediary product, then a new object 102 must be created. This presents a heavy programming burden on the AD tool user.

Still further, with the potential solution of Fig. 1, the AD tool developer must decide to provide the support for a specific intermediary program product, by providing the special API 111, thus creating a further programming burden on the part of the AD tool developer.

4 Summary of the Invention

According to a first aspect, the present invention provides a data processing apparatus, providing a platform for running a called software program to which a calling software program can make a call, the apparatus comprising: receiving means for receiving a call from the calling software program, the call including a pointer to a data mapping object which has an input state having data in a predetermined format; and means for calling the data mapping object and retrieving the data mapping object's input state in the predetermined format; wherein the data mapping object maps data provided by the calling program from a second format used by the calling program, which is different from the predetermined format, into the predetermined format, as the data mapping object's input state.

is According to a second aspect, the present invention provides a method including method steps corresponding to the features recited in the first aspect of the present invention.

According to a third aspect, the present invention provides a computer program product, stored on a computer readable storage medium, for, when run on a computer, carrying out the data processing method of the second aspect of the present invention.

Thus, with the present invention, an open standard is achieved whereby a wide variety of program products (e.g., transaction monitor, message/queuing product or database product) can be adapted to accept OOP programming constructs from a calling program by generating only one mapping object via an AD tool (e.g., visual Age for Java) and then passing a pointer to this mapping object to the program product's API.

The AD tool user does not need to create a separate mapping object for each program product. once the mapping object is generated, it can be used to communicate with a wide variety of program products, because the interface between the data mapping object and the program product's API is a generic one (i.e, it is not limited to any one program product).

Also, the AD tool user, in creating the mapping object, does not need to know the details of the program product (e.g., CICS) he is creating the mapping object to adapt to, nor even does he need to know which intermediary program product the mapping object will be communicating with. Thus, in situations where a variety of program products are to be supported, this makes the use of an AD tool much easier and greatly reduces the programming burden involved, as only a single mapping object need be generated. 5 Further, with the present invention, because the interface between the data mapping object and the program product's API is not specific to any particular AD tool, a wide variety of different AD tools can be used in generating the data mapping object.

Brief Description of the Drawings

The present invention will be better understood through a description of a preferred embodiment thereof, to be given below in conjunction with the following drawing figures:

Figure 1 is a block diagram showing software components running within a data processing unit, according to a possible solution which does not provide the advantageous results that an embodiment of the present invention provides; and Figure 2 is a block diagram showing software components running within a data processing unit, according to a preferred embodiment of the present invention.

Detailed Description of the Preferred Embodiments of the Present

Invention AS shown in Fig. 2, the CICS program 212 includes a Java byte array API 212b, which is the same as the Java byte array API 112a of Fig. 1.

Further, the CICS program 212 has a Java Data Mapping API 212a, which will be described below. Still further, a data mapping object 202 has been created using an AD tool 22, so that the Java program 201 can use the data mapping object 202 to send object-oriented requests to the CICS program 212.

when the Java program 201 begins a processing task, it passes to the data mapping object 202 some data (e.g., name and address data of a customer), which is in a format defined by the particular AD tool (the VAJ tool 22 in this case) that has been used to create the data mapping object 202, to be used to call the CICS program 212 (e.g., Java program 201 calls a setNameo method on the data mapping object 202. The data mapping object 202 then maps the user data supplied by the Java program 6 201 into a byte array format and stores it as the object 202's input state. Java program 201 then makes a direct call to the Java Data mapping API 212a of the CICS program product 212, passing a pointer to the data mapping object 202 as a parameter. The API 212a accepts a pointer to the mapping object as either an input or an output parameter, or both. Upon receiving this call, the Java data mapping API 212a calls a getContentso method on the data mapping object 202. In response to the receipt of this call, the data mapping object 202 executes the getcontentso method and retrieves the byte array stored as its input state and passes it from the data mapping object 202 to the Java Data Mapping API 212a. The Java Data mapping API 212a then takes the byte array and passes it along to the Java byte array API 212b which passes it to CICS processing unit 212c. Accordingly, the CICS processing unit 212c receives commands in the same format as it has been receiving them long before Java programs came into being. CICS processing unit 212c, thus, does not realize that the commands have originated from a Java program.

The CICS processing unit 212c then carries out normal CICS processing tasks, which could involve the invoking of a further program 214 and/or the accessing of a data store 213. Eventually, the CICS processing unit 212c develops a reply to be sent back to the requesting program 201. The CICS processing unit 212c passes its reply to the Java byte array API 212b which passes it along to the Java data mapping API 212a in byte array format. Java data mapping API 212a then makes an updateContentso method call to the data mapping object 202, passing along the byte array format reply. This call instructs the data mapping object 202 to update the contents of the data mapping object's output state with the newly received byte array data in the reply. The data mapping object 202 then maps the byte array format reply back into the format of the particular AD tool 22 that was used to generate the data mapping object 202 (in this case, the VAJ AD tool 22) and supplies the reply to the Java program 201.

In another embodiment, two separate data mapping objects are provided, one storing the input state and the other storing the output state.

it should be noted that it is not a requirement that the input/output state(s) be stored via the data mapping object(s) Instead, the data can be converted as it passes through the data mapping object without necessarily storing it.

7 The data mapping object 202 and the Java Data Mapping API 212a, according to the preferred embodiment of the present invention, support a set of Java interfaces and a set of matching protocols which will be described in detail below. The method implementations are in the data mapping object 202 and the Java data mapping API 212a calls such methods.

The data mapping object 202 is generic in the sense that once it is created, it can be used, without change, to interface between an object oriented program (e.g. 201) and a wide variety of program products (one of which is CICS 212). Such program products would have to be supplied with a data mapping API (similar to 212a) but specifically directed to the particular program product (for example, the Java data mapping API 212a in Fig. 2 is specifically directed to the CICS product 212). The interface between the API 212a and the mapping object 202 is also generic to a wide variety of program products.

The data mapping object 202 could be created using any of a wide variety of AD tools (it is not necessary to use the VAJ tool 22) without any change to the Java data mapping API 212a. That is, if the system were up and running with a data mapping object 202 created using the VAJ tool 22 communicating with the Java data mapping API 212a and the Java program 201 (as illustrated in Fig. 2) and then, at a later time, it is desired to create a new data mapping object 202, (not shown in Fig.) using a different AD tool 22, to communicate with a different Java program 2011, then there is no need to change the Java data mapping API 212a. The data mapping object 202 would carry out a different mapping because the AD tool has changed (the mapping is now from the data format of the new AD tool 22, to the byte array format and vice versa), but the interface between the data mapping object 202 and the Java data mapping API 212a stays the same.

There are two interfaces /protocols which a data mapping object (e.g., 202) and a Java Data Mapping API 212a supports, according to a preferred embodiment of the present invention. These are called "Simple Datamappingn and "Locking DataMapping". These define the relationship (or contract) between the mapping object 202 and the Java Data Mapping API 212a. of course, the invention is not limited to these two interfaces/protocols since any number of extensions could be defined.

Data mapping objects should support being constructed from a byte array greater in length than necessary to support their particular mapping, either via a Java constructor or via the updateContentsomethod.

8 Simple DataMapping If a data mapping object does not support the locking of the data while it is being passed to a product then it can implement the DataMapping interface. This interface consists of only two methods:

getContents () and updateContents (). These method names are chosen deliberately to avoid a JavaBean property called contents from being deduced by the JavaBeans runtime or tools. The ways in which these methods are called is determined by whether the product operation treats the argument represented by the data mapping object as input only, output only or both input and output.

In the case of an input-only parameter, only the getContentso method will be called.

In the case of an output-only parameter, only the updateContentso method will be called, assuming the operation succeeded. If the operation did not succeed, updateContentso would not be called.

In the case of a parameter that is both input and output, 2 0 getContentsO will be called followed by updateContents(), assuming the operation succeeded. If the operation did not succeed, updateContentso would not be called.

Locking Datamapping A more sophisticated data mapping object that prevents other clients from seeing changes to the data until an operation completes can implement the Lock ingDataMapp ing interface. This interface adds a new method, releaseContentso, and changes the way that the methods in the DataMapping interface are called. whenever a data mapping object that implements LockingDatamapDing is used as a parameter to an operation, getContentso is called to notify the mapping object that the data is liable to be used. If the call to getContentso returns a value other than null then the product must call releaseContentso passing in the value returned by getContentso. The sequence of method calls for the three cases is as follows:

In the input-only case, the product calls getContentso followed by releaseContentso.

In the output-only case, the product calls getContentso followed by updateContents () followed by releaseContents assuming the operation 9 succeeded. If the operation failed, the sequence of calls would be getcontentso followed by releaseContentso.

In the input-and-output case, the sequence of calls is the same as the output-only case. The difference in this case is that the data returned from getContentsO is used whereas in the output-only case it is not used.

The attached Appendices 1, 2 and 3 list the Java source files that define/embody these interfaces, according to a preferred embodiment of the present invention.

The attached Appendix 4 lists the Java source file of a mapping object, according to a preferred embodiment of the present invention.

APPENDIX 1 This interface is suitable for simple data mapping objects which do not require any locking while the underlying byte array is being manipulated by a <Product>. This interface is used to implement a protocol between the <Product> and the object providing the mapping. There are actually three different protocols: <OL> <LI> A read-only protocol <LI> A write-only protocol <LI> A read-write protocol </OL> in the read-only case, the getContentso method is invoked, potentially repeatedly, without any calls to updateContentso method. In the writeonly case, the updateContentso method is invoked, potentially repeatedly, without any calls to the getContents() method. In the read-write case, the getContentso method is invoked and then, if the operation using the contents is successful, the updateContentso method is invoked. If the operation is unsuccessful then the getContents() method could be called again, without an intervening updateContents 0 method call. public interface Datamapping Return the contents of the mapping.

if the length of the byte array that is holding the contents is greater than is required, which can occur if the mapping is constructed from a larger byte array, then a copy of the correct length must be returned so that the correct size is passed to a <Product> that requires it. byte[] getContentso throws inval i dDataMapp ingExcept ion; update the mapping from the supplied array of bytes.

This array may be longer than is necessary to support the mapping.

The mapping does not have to store the reference to the array, or return the same reference from the getContentso method.

It is up to the user of the mapping to copy from the byte array returned by this method as required.

@param. contents a byte array containing the data that is to be mapped.

@exception IllegalArgumentException the array is invalid for this mapping void updateContents (byte[] contents) throws I llegalArgumentExcept ion; H APPENDIX 2 Exception that indicates a DataMapping contains invalid/inconsistent data.

public class InvalidDataMappingException extends Exception public InvalidDatamappin9Exceptiono supero; 1 public InvalidDataMappingException(string s) super(s); APPENDIX 3 This interface is suitable for data mapping objects which provide locking/ synchronization support when the underlying byte array is being manipulated by a <Product>.

in this case, when a data mapping object receives a <CODE>getContentsO</CODE> call it should note the fact that the underlying byte array is liable to be changed at any time as it has been passed to a <Product>, and behave accordingly if other threads attempt to manipulate the data structure.

When an <CODE>updateContents</CODE> call is received, the data mapping object should reflect the changes back into the underlying byte array so that clients will see the updated values.

if it tracks the callers of <CODE>getContentsO</CODE> it should remember this caller until <CODE>releaseContentsO</CODE> is called.

- If a call to getContents 0 returns a value other than null, the <Product> guarantees to call releaseContents 0 with the value returned from getContentso.

There may or may not have been an intervening call to updateContents depending on whether or not the operation was read-only or, if it was read-write, if the operation succeeded or not.

An object that implements LockingDataMapping will always have its getcontents 0 method invoked before updateContents public interface LockingDataMapping extends DataMapping Indicate that the contents (or this particular copy of them) are no longer needed. This call must be made whether or not the contents are changed. void releaseContents (byteH contents) throws 11 legalArgumentExcept ion; APPEMIX 4 This class is a very simple data mapping class. It supports a single attribute which is a long.

public class LongMapping implements Datamapping private byteH contents; // Default constructor public LongMapping() contents = new byte[81; J // Constructor for an existing byte array, which must be at least 8 bytes public Longmapping(byte[l contents) if (contents.length ≥ 8) this.contents = contents; else throw new IllegalArgumentException(lllength must be at least 8m); This is the method the product calls to ask the mapping object for the byte array representation of the user data.

public synchronized byte[] getContentso throws Inval i dDataMappingExcept ion byte[] result = null; if (contents.length > 8) Need to return a copy result = new byte[81; System. arraycopy (contents, 0, result, 0, 8); else Can return original result = contents; return result; This is the method the product calls to update the mapping object with a new byte array. public synchronized void updateContents (byte[] newContents) if (contents.length > 8) newcontents must be the copy System.arraycopy(newContents, 0, contents, 0, 8); 11-111, This is the method the application uses to read the value of the property. public synchronized long getLong() long result = 0; result = Mlong) (contents [71) & Oxff) << 56) (((long)(contents[31) & Oxff) << 48) (((long)(contents[ll) & Oxff) << 40) Mlong)(contents[41) & Oxff) << 32) Mlong)(contents[21) & Oxff) << 24) (((long)(contents[O1) & Oxff) << 16) Mlong)(contents[51) & Oxff) << 8) ((long)(contents[61) & Oxff); return result; This is the method the application uses to write the value of the property. public synchronized void setLong(long value) contents[O] = (byte) ((value >> 16) & Oxff); contents[l] = (byte) ((value >> 40) & Oxff) contents[21 = (byte) ((value >> 24) & Oxff) contents[31 = (byte) ((value >> 48) & Oxff) contents[41 = (byte) ((value >> 32) & Oxff) contents[51 = (byte) ((value >> 8) & Oxff) contents[61 = (byte) ( value & Oxff) contents[71 = (byte) ((value >> 56) & Oxff) I Ar I 1 IT

Claims

1. A data processing apparatus, providing a platform for running a called software program to which a calling software program can make a call, the apparatus comprising:

receiving means for receiving a call from the calling software program, the call including a pointer to a data mapping object which has an input state having data in a predetermined format; and means for calling the data mapping object and retrieving the data mapping object's input state in the predetermined format; wherein the data mapping object maps data provided by the calling program from a second format used by the calling program, which is different from the predetermined format, into the predetermined format, as the data mapping object's input state.

2. The apparatus of claim 1 further comprising:

means for processing the call received by the receiving means and for providing a reply in the predetermined format; and means for calling the data mapping object and passing the reply in the predetermined format to an output state of the data mapping object in the predetermined format; wherein the data mapping object maps data in its output state to the second format used by the calling program before sending such data to the calling program.

3. The apparatus of claim 1 wherein:

the receiving means receives a call from the calling software program, the call including a pointer to a data mapping object which has an input state having data in a predetermined format and a pointer to a second data mapping object which has an output state.

4. The apparatus of claim 3 further comprising:

means for processing the call received by the receiving means and for providing a reply in the predetermined format; and means for calling the data mapping object and passing the reply in the predetermined format to the second data mapping object's output state in the predetermined format; wherein the second data mapping object maps data in its output state to the second format used by the calling program before sending such data to the calling program.

16

5. The apparatus of claim 1, wherein the data mapping object is generated by an application development tool.

6. The apparatus of claim 5 wherein the second format is determined by the application development tool.

7. The apparatus of claim I wherein the predetermined format is a byte array format.

8. The apparatus of claim 1 wherein the calling program is an objectoriented software program.

9. The apparatus of claim 8 wherein the calling program is a Java program. 15

10. The apparatus of claim 2 wherein the means for processing calls another software program in the course of providing the reply.

11. The apparatus of claim 2 wherein the means for processing calls a 20 data store in the course of providing the reply.

12. The apparatus of claim 1 wherein the data mapping object stores data in a predetermined format in its input state.

13. The apparatus of claim 2 wherein the data mapping object stores the reply in the predetermined format as the output state in the predetermined format.

14. The apparatus of claim 3 wherein the data mapping object stores data in the predetermined format as its input state.

15. The apparatus of claim 1 wherein the called program is a transaction monitor program.

16. The apparatus of claim 1 wherein the called program is a messaging and queuing program.

17. The apparatus of claim 1 wherein the called program is a database management program. 40

18. The apparatus of claim 1 wherein the calling program and the called program are running on the apparatus.

19. The apparatus of claim 18 wherein the calling program and the called program are running in the same process on the apparatus.

20. The apparatus of claim 18 wherein the calling program and the called program are running in separate processes on the apparatus.

21. The apparatus of claim 1 wherein the calling program is running on a separate data processing apparatus.

22. A data processing method of running a called software program to which a calling software program can make a call, the method comprising:

receiving a call from the calling software program, the call including a pointer to a data mapping object which has an input state having data in a predetermined format; and calling the data mapping object and retrieving the data mapping object's input state in the predetermined format; wherein the data mapping object maps data provided by the calling program from a second format used by the calling program, which is different from the predetermined format. into the predetermined format, as the data mapping object's input state.

23. The method of claim 22 further comprising steps of:

processing the received call and providing a reply in the predetermined format; and calling the data mapping object and passing the reply in the predetermined format to an output state of the data mapping object in the predetermined format; wherein the data mapping object maps data in its output state to the second format used by the calling program before sending such data to the calling program.

24. The method of claim 22 wherein:

in the receiving step, a call is received from the calling software program, the call including a pointer to a data mapping object which has an input state having data in a predetermined format and a pointer to a second data mapping object which has an output state.

25. The method of claim 24 further comprising:

26. The method of claim 22, wherein the data mapping object is generated by an application development tool.

27. The method of claim 26 wherein the second format is determined by the application development tool.

28. The method of claim 22 wherein the predetermined format is a byte array format.

29. The method of claim 22 wherein the calling program is an object oriented software program.

30. The method of claim 29 wherein the calling program is a Java program.

31. The method of claim 23 wherein the means for processing calls another software program in the course of providing the reply.

32. The method of claim 23 wherein the means for processing calls a data store in the course of providing the reply.

33. The method of claim 22 wherein the data mapping object stores data in a predetermined format in its input state.

34. The method of claim 23 wherein the data mapping object stores the reply in the predetermined format as the output state in the predetermined format.

35. The method of claim 24 wherein the data mapping object stores data in the predetermined format as its input state.

36. The method of claim 22 wherein the called program is a transaction monitor program.

37. The method of claim 22 wherein the called program is a messaging and queuing program.

38. The method of claim 22 wherein the called program is a database management program.

39. The method of claim 22 wherein the calling program and the called program are running on a data processing apparatus.

40. The method of claim 39 wherein the calling program and the called program are running in the same process on the apparatus.

41. The method of claim 39 wherein the calling program and the called program are running in separate processes on the apparatus.

42. The method of claim 22 wherein the calling program is running on a separate data processing apparatus from the data processing apparatus on which the called program is running.

43. A computer program product, stored on a computer readable storage medium, for, when run on a computer, carrying out a data processing method involving a called software program to which a calling software program can make a call, the method comprising:

receiving a call from the calling software program, the call including a pointer to a data mapping object which has an input state having data in a predetermined format; and calling the data mapping object and retrieving the data mapping object's input state in the predetermined format; wherein the data mapping object maps data provided by the calling program from a second format used by the calling program, which is different from the predetermined format, into the predetermined format, as the data mapping object's input state.