JPH11353168A - Interface matching method and recording medium where interface matching program is recorded - Google Patents

Abstract

PROBLEM TO BE SOLVED: To lighten the burden on an application programmer by automatically generating a code for putting together components to be reused. SOLUTION: If a component to be reused on a client side is different from an interface that the client side requires and can not be reused (a), a glue code generating device 1 mounts the client-side interface and automatically generate a code for putting together the components to be reused (b). Namely, differences due to methods and the order of arguments are absorbed from the interface descriptions of the client side and component side to extract the correspondence relation between the methods and arguments. When plural correspondence relations are present and not clear, the user is allowed to make a choice among candidates. The correspondence relation is used to define a new component mounted with the client-side interface and a programming code for putting together the components to be reused is automatically generated therein.

Description

DETAILED DESCRIPTION OF THE INVENTION

[0001]

BACKGROUND OF THE INVENTION 1. Field of the Invention The present invention relates to the reuse of software components, and more particularly to an interface matching method which can automatically generate a code mediating between a component side interface and a client side interface when the interface is different. And a recording medium on which an interface matching program is recorded.

[0002]

2. Description of the Related Art The prior art will be described with reference to FIGS. When reusing software components,
It is essential that the component side and the client side interface match. Conventionally, in the situation where only the interface as shown in FIG. 7 is implemented as the component side, if the client side requests the use of the interface as shown in FIG. 8, there is a mismatch in the specifications between the interfaces. There was a problem that components could not be reused in an unusual form.

As a method for solving the above problem, in component-oriented programming, as shown in FIG.
A component that implements the client-side interface is newly defined, and the components to be reused are aggregated (aggre
gate) handwritten code.

[0004]

However, it is not possible to newly define a component that implements a client-side interface and hand-write a code for aggregating components to be reused while considering the correspondence between methods and arguments. While it was obvious to application programmers, there was a problem that it was complicated.

The present invention has been made in view of the above-mentioned drawbacks of the related art, and reduces the burden on an application programmer by providing a means for automatically generating a code for aggregating components to be reused. The purpose is to:

[0006]

According to the present invention, as shown in FIG. 1A, components (Ccomponent1 and Ccomponent2) to be reused on a client (Cclient) side are different from interfaces required by the client side. Fig. 1
As shown in (b), the glue code creating device 1
By automatically generating code that implements the client-side interface and aggregates the components to be reused, it matches the interfaces and makes them reusable.

In the present invention, specifically, the following method is used. (1) The client-side and component-side interface descriptions are input, and the methods included in each interface and the arguments included in each method are extracted (see FIG. 2).

(2) When there are a plurality of component side interfaces, the methods included in the component side interface are collectively recognized as component side methods (see FIG. 2).

(3) On the component side, the method corresponding to the interface side method is extracted. If the number of arguments, return type, and all argument types match in both methods, it is defined as corresponding (Fig. 3
reference).

(4) All combinations are checked, and when the client side method corresponds to a plurality of component side methods, the user is made to select (see FIG. 3). (5) For each corresponding method on the client side and the component side, extract the correspondence between arguments (Fig. 4
reference).

(6) A new component implementing the client-side interface is defined by using the correspondence between the methods and arguments on the client side and the component side (see FIG. 5).

(7) The components to be reused are aggregated therein, and when the interface-side method is activated, a code for appropriately invoking the component-side method is automatically generated from the correspondence between the method and the argument ( See FIG. 6).

As described above, the code for implementing the client-side interface and aggregating the components to be reused has been conventionally handwritten. However, according to the present invention, the code can be automatically generated, so that the burden on the application programmer is increased. Can be reduced.

[0014]

DESCRIPTION OF THE PREFERRED EMBODIMENTS A description will be given of how a programming code shown in FIG. 9 is automatically generated from a description of a component-side interface shown in FIG. 7 and a client-side interface shown in FIG. 8 in accordance with the processing flowcharts of FIGS. Thus, an embodiment of the present invention will be described.

The overall configuration of the embodiment of the present invention is as follows.
The "interface matching routine" calls the "method order corresponding routine", the "method order corresponding routine" calls the "argument order corresponding routine",
When the “interface matching routine” ends, the process transits to the “glue code creation routine”, and the “glue code creation routine” calls the “method code creation routine”.

In this example, the interfaces and methods are defined as follows. Interface: Method 1, Method 2, ..., Method N Method: Return type Method name (Argument type 1 Argument name 1,
Argument type 2 Argument name 2, ..., argument type N Argument name N) For example, in the interface shown in FIG.
Is “Integer getID (String name)”, method 2 is “void putID (String name, Integer ID)”, method 3 is “void setID (Integer ID, String name)”,
The number of methods is 3. For method 1,
Return type Integer, method name is getID, argument type 1 is Str
ing, argument name 1 is name, and the number of arguments is 1. According to this definition, each method can be classified as follows.

Interface name Method name Number of arguments Return type Iclient getID 1 Integer Iclient putID 2 void Iclient setID 2 void Icomponent1 setIt 2 void Icomponent2 putIt 2 void Icomponent2 getIt 1 Integer Icomponent2 dummy 2 Integer [1] Example of interface matching FIG. 4 is a processing flowchart of an interface matching routine.

An example of the interface matching routine when a client-side interface description (FIG. 8) and a component-side interface description (FIG. 7) are input will be described.

In the interface matching routine, the inputs are the client-side interface, the component-side interfaces 1,..., And the interface N, and the outputs are the client-to-component side correspondence between methods and the argument correspondence between each method. .

(1) If the component side has a plurality of interfaces, the method of each interface is recognized as a component side method (step S10).
1). In this example, the component side interface is 2
, Four methods are recognized as component-side methods.

(2) The number of client-side methods and the number of component-side methods are compared (steps S102 to S103). In this example, the client side is 3,
Since the number of components is 4, and the number of components is large, the process proceeds to step S104.

(3) The number of methods is totaled for each method having the same return type and the same number of arguments (hereinafter referred to as conditions), and the client side and the component side match (step S).
104). In this example, the methods are classified as follows for each condition. For the conditions of the number of arguments: 1, return type: Integer and the number of arguments: 2, return type: void, the method is used on the client side and component side. The numbers match, but they do not match under the conditions of number of arguments: 2, return type: Integer.

Client side: number of arguments Return value number of methods 1 Integer 1 2 void 2 Component side: number of arguments Return value number of methods 2 void 21 Integer 1 2 Integer 1 (4) If there are many components, client side The component side method is excluded from consideration so that the number becomes the same as (step S105). In addition, when there are a plurality of candidates and it is ambiguous, necessary information is displayed to allow the user to select. In this example, regarding the number of arguments: 2, the return type: Integer, 0 components on the client side and 1 component side
Therefore, the component side method (dummy) is excluded from consideration so that the number is the same as the client side.

(5) It is confirmed whether the number of methods for each condition matches on the client side and the component side (step S106). In this example, since they match, step S10
Transition to 7.

(6) A condition list having a return type and the number of arguments as attributes is created for each method having the same condition (step S107). In this example, the following condition list is created.

[0026] (7) Call a method order correspondence routine for each condition (steps S108 to S110). In this example, the following result is returned.

Result for condition 1: client-side component side getID getIt method ID It argument setID setIt method Result for condition 2: client-side component side putID putIt method name index argument ID It argument setID setIt method ID It argument name index argument (8 It is checked whether all the conditions have a corresponding relationship (steps S111 to S112). In this example, since there is a correspondence between all of the conditions, the process proceeds to the glue code creation routine (step S113). [2] Example of method order association FIG. 3 is a processing flowchart of a method order association routine.

A description will now be given of an embodiment in which the condition 2 in the above-described example of interface matching is input with respect to the method order correspondence routine. The inputs to the method order correspondence routine are methods 1,..., Method N that satisfy the conditions (the number of arguments and the return type) on the client side and the component side. The output is the method correspondence between the client side and the component side, and the correspondence between the arguments in each method.

The methods satisfying the condition 2 on the client side and the component side are shown below. Client side void putID (String name, Integer ID) void setID (Integer ID, String name) Component side void setIt (String index, Integer It) void putIt (Integer It, String index) (1) Component side method group (method 1 ,..., Method N), a brute force method order list is created (step S201). In this example, the following method order list is created.

First method order: 1 void setIt (String index, Integer It) 2 void putIt (Integer It, String index) Second method order: 1 void putIt (Integer It, String index) 2 void setIt (String index, Integer It) (2) An argument order correspondence routine is called for each method order (steps S202 to S204). In this example, the following result is returned.

Result of the first method order: PutID setIt method on the client side component name index argument ID It argument setID putIt method ID It argument name index argument Result in the second method order: putID putIt method name index argument on the client side component side ID It Argument setID setIt Method ID It Argument name index Argument (3) If there is more than one correspondence in each method order, the user is made to select from the candidates and the result is stored (step S205). In this example, since there is a correspondence between the first and second method orders, the user is made to select. Hereinafter, it is assumed that the result in the second method order is selected.

(4) Return to the caller of this routine (step S206). [3] Example of Argument Order Correlation FIG. 4 is a processing flowchart of an argument order association routine.

With respect to the argument order associating routine, an embodiment when the second method order in the above example of the method order associating is input will be described. The input to the argument ordering routine is the client-side method order (method 1,..., N) and the component-side method order (method 1,..., N), and the output is the argument correspondence (existence) for each method. If not: NULL)
It is.

The method order input on the client side and the component side is shown below. Client side 1: void putID (String name, Integer ID) 2: void setID (Integer ID, String name) Component side 1: void putIt (Integer It, String index) 2: void setIt (String index, Integer It) (1 A method pair list is created that directly corresponds to the client-side method order and the component-side method order (step S301). In this example, the following method pair list is created.

1: Client side: void putID (String name, Integer ID) Component side: void putIt (Integer It, String index) 2: Client side: void setID (Integer ID, String name) Component side: void setIt (String index, Integer It) (2) For each method pair, create a possible combination of the order of the arguments in the component-side method, and extract the correspondence in which the argument types match the client side (steps S302 to S304). In this example, the following comparison is performed on the first method pair.

Client side void putID (String name, Integer ID) Component side void putIt (Integer It, String index) No match void putIt (String index, Integer It) Match (3) For each method pair, If there is a correspondence, let the user select from the candidates,
The result is stored (step S305). In this example, the first
Since there are no multiple correspondences for method pairs,
The following correspondence is stored as it is.

Client side component side putID putIt method name index argument ID It argument (4) If there is an order of arguments that matches all method pairs, the correspondence is stored (step S306).
In the example, since there is a correspondence corresponding to all the method pairs, these are stored. For the second method pair, the following correspondence is stored.

Client side component side setID setIt method ID It argument name index argument (5) Return to caller of this routine (step S30)
7). [4] Example of Glue Code Creation FIG. 5 is a processing flowchart of a glue code creation routine.

FIG. 7 shows the glue code creation routine.
A description will be given of an example in which the component-side and client-side interfaces shown in FIG. 8 and the result output by the interface matching routine in this example are input.

The inputs to the glue code creation routine are the client-side interface, the component-side interfaces 1,..., N, the correspondence between methods on the client and component sides, and the correspondence between arguments for each method. The output is a code (glue code) that can operate the component-side interface transparently by operating the client-side interface.

The results output by the interface matching routine are shown below. Client side component side getID getIt method ID It argument setID setIt method client side component side putID putIt method name index argument ID It argument setID setIt method ID It argument name index argument (1) Outputs component definition header code that implements client side interface Then, the component implementing the component-side interface is instantiated for each component-side interface, and a code for obtaining a reference is output (from step S401 to step S401).
402). In this example, the following code is output.

[0042] (2) Create a method list using the method order in the client-side interface (step S40)
3). In this example, the following method list is created.

1: Integer getID (String name) 2: void putID (String name, Integer ID) 3: void setID (Integer ID, String name) (3) Call a method code creation routine for each method (from step S404 S406). In this example, the following code is output.

[0044] (4) The component definition footer code is output (step S407). In this example, the following code is output.

｝ (5) End (step S408). [5] Example of Method Code Creation FIG. 6 is a processing flowchart of a method code creation routine.

An embodiment of the method code creation routine when the second method in the example of glue code creation described above is input will be described. The input to the method code creation routine is a client-side method, and the output is a code that activates a method corresponding to the client-side method, which is an instantiated component.

The second method in the example of glue code creation is shown below. void putID (String name, Integer ID) (1) A code for declaring the same method as that of the client-side interface for the method is output (step S501). In this example, the following code is output.

Public void putID (String name, Integer ID) (2) When the method returns a value, a code for returning the value (eg, return) is output (steps S502 to S503). In this example, nothing is output because the input client-side method does not return a value.

(3) In an instance of a component in which an interface including a method corresponding to the method is mounted on the component side, a code for activating the method corresponding to the method is output on the component side (step S504). In this example, from the extracted method correspondence, putID corresponds to the component side method putIt, and putIt corresponds to the component
Since it is implemented in Ccomponent1, the reference to the instance is p1. As a result, the following code is output.

P1.putIt ((4) An argument list of the corresponding method is created on the component side (step S505) In this example, the following argument list is created from the argument list of putIt.

1: Integer It 2: String index (5) For each argument, the client outputs an argument name corresponding to the argument (from step S506 to step S50)
8). In this example, It is an ID on the client side, and index is
The following code is output to correspond to name.

ID, name (6) A footer code is output for the method (step S509). In this example, the following footer code is output.

[0053] (7) Return to the caller of this routine (step S51)
0).

[0054]

As described above, according to the present invention,
When the component-side interface and the client-side interface are different, it is possible to automatically generate a code that mediates both.

This eliminates the conventional complicated processing of newly defining a component implementing the client-side interface and handwriting a code for aggregating components to be reused while considering the correspondence between methods and arguments. This has the effect of reducing the burden on the application programmer.

[Brief description of the drawings]

FIG. 1 is a diagram illustrating the principle of the present invention.

FIG. 2 is a processing flowchart of an interface matching routine.

FIG. 3 is a processing flowchart of a method order association routine.

FIG. 4 is a processing flowchart of an argument order associating routine.

FIG. 5 is a processing flowchart of a glue code creation routine.

FIG. 6 is a processing flowchart of a method code creation routine.

FIG. 7 is a diagram illustrating an example of a component-side interface.

FIG. 8 is a diagram illustrating an example of a client-side interface.

FIG. 9 is a diagram illustrating an example of an interface of a component that implements a client-side interface.

[Explanation of symbols]

 1 glue code creation device

Claims (2)

[Claims] 1. A method for reusing one or more software components having an interface different from an interface requested by a client, wherein differences in the order of methods and arguments are absorbed from interface descriptions on a client side and a component side. And the correspondence between parameters and arguments are extracted. If there is more than one correspondence between methods and arguments and the user is ambiguous, the user is selected from candidates, and the client-side interface is implemented using the correspondence between methods and arguments. An interface matching method characterized by automatically generating programming code for defining a component and aggregating components to be reused inside the component. 2. An interface description on a client side and a component side in a recording medium storing a program for causing a computer to execute a method of reusing one or more software components having an interface different from an interface requested by a client. Absorbs differences due to the order of methods and arguments from
The correspondence between methods and arguments was extracted, and if there was more than one correspondence between methods and arguments, the user was selected from the candidates if ambiguous, and the client-side interface was implemented using the correspondence between methods and arguments. A recording medium on which an interface matching program is recorded, wherein a program for causing a computer to execute a process of defining a new component and automatically generating a programming code for aggregating components to be reused inside the component is recorded.