JP2006343867A - Object oriented programming device and information processing method - Google Patents

Abstract

<P>PROBLEM TO BE SOLVED: To reduce memory capacity needed by a generated program and improve the execution speed while keeping readability and maintenance property, in an object-oriented programming device. <P>SOLUTION: The object-oriented programming device for executing object-oriented programming based on model information expressing a configuration of software comprises a model information storage part 202 storing the model information; a class integration part 208 integrating integrable classes from the model view information; a class-integrated program automatic generation part 211 generating a program based on the model information in which the classes are integrated in the class integration part 208; and a program display part 208 displaying the program generated in the class-integrated program automatic generation part 211. <P>COPYRIGHT: (C)2007,JPO&INPIT

Description

  The present invention relates to an object-oriented programming generation apparatus that automatically generates a program from a software drawing designed using an object-oriented analysis / design technique.

  In recent years, object-oriented analysis design has become widespread as one of software analysis design methods. Here, the object-oriented analysis and design is a development technique in which a real-world entity is extracted as an object, and a system is configured with this object as a unit.

  In the development method of object-oriented analysis and design, an abstraction of the same kind of object is called a “class”, and a “class diagram” is described to express the structure between the extracted classes. Each class has a role, and “attributes” for describing internal data held by the class and “functions” representing operations on the class are defined.

  Further, the entire system requests processing between classes and cooperates with each other to realize one large process. In this case, a request for processing from a certain class to another class is called a “message” and is further roughly classified into a “synchronous message” and an “asynchronous message” depending on the processing method. A synchronous message is a message that is typified by a normal function call, and the caller waits for the completion of processing and transitions to the next processing. On the other hand, an asynchronous message is usually called an “event”, and the caller waits for the completion of processing. Since the next process is executed without waiting, parallel processing is realized between the call source object and the call destination object. A class that receives an event in this way and triggers the event to change its own state and executes a specific action is referred to as an “active class”. This active class is used to illustrate the state change and the action to be performed. Holds a “state diagram”. On the other hand, a class that does not receive an event and does not have a state diagram is referred to as a “passive class”.

  In order to support system development using the object-oriented analysis design, an object-oriented design support apparatus has been proposed. An object-oriented design support apparatus is an apparatus that supports creation of a software design drawing used for object-oriented development using an information processing apparatus such as a computer. Further, in the object-oriented design support apparatus, a method of creating a software design drawing by a notation called Unified Modeling Language (hereinafter referred to as UML) has become mainstream. For example, the above class diagram and state diagram are also described based on UML.

  Furthermore, an object-oriented programming generation apparatus has been proposed in order to automatically generate a program from a software design drawing described based on the UML. In the object-oriented programming generation apparatus, an operable program is input by inputting model drawing information described by a user and a conversion rule for converting the model drawing information into a program such as C, C ++, Java (registered trademark), for example. It is possible to generate automatically.

  A sufficiently practical method is required as a means for automatically generating a program with higher performance without impairing the specifications of the analyzed / designed software from the model drawing information described by the user.

  For example, if a program is automatically generated based on model drawing information that has been divided into more detailed classes in order to enhance the understanding of the designer in accordance with the object of object-oriented analysis and design, the memory required to execute the generated program The problem of increased size arises. In particular, when a program that is automatically generated is incorporated in a device, the memory size that can be used by the program is often limited, and this problem is serious.

  In addition, when a program is automatically generated based on model drawing information that has been subjected to more detailed class division, another problem arises that the execution speed becomes slow. This problem also becomes a big problem, especially when the generated program is incorporated in the device, and the optimum speed and timing control often greatly affect the product specifications.

  The applicant of the present application is considering solving such a problem by integrating a plurality of classes analyzed in the class diagram and reducing the number of classes.

  Hereinafter, the reason why the memory size necessary for executing the program is large is as follows. Normally, when a program is automatically generated from a model diagram, a set of source code files is generated for one class. At this time, each source code has an overhead for realizing the class definition on the program.

  The overhead for the memory size is caused by, for example, the declaration of a class name, the definition of a constructor / destructor function, the definition of a state transition table in an active class, and the like. These effects vary depending on the type of programming language to be generated and the mapping method, but are required each time a new class is defined. As a result, the memory size required for executing the program increases.

  Here, for example, when a specific analysis part in which model diagrams are described as two classes is integrated / analyzed as one class, the overhead for realizing the above class definition is omitted for one class, As a result, it is possible to reduce the memory size required for executing the automatically generated program.

  Subsequently, the reason why the execution speed is slow is that, generally, when processing is requested from a class to another class, more overhead processing time is required compared to processing closed within the class.

  This overhead for processing time occurs remarkably in a system in which processing requests between classes are realized by event transmission / reception. Usually, in order to realize parallel processing between classes, processing such as queuing of events and extraction of queued events occurs, and a lot of execution time is required to realize these processings.

  Here, when the processing request between these classes can be realized as processing within the class, the overhead processing time is removed, and the processing can be executed at higher speed. Furthermore, for systems in which requests for processing between classes are realized by sending and receiving events, events that were sent and received by integration can be replaced with synchronous messages (function calls), greatly reducing processing time. Realized.

  Thus, by reducing the number of classes to be analyzed in the class diagram, it is possible to reduce the size of the automatically generated program or improve the execution speed.

  On the other hand, as a prior art similar to the above solution studied by the applicant of the present application, for example, Japanese Patent Laid-Open No. 09-146766 is cited.

Specifically, “Class structure changing method (Japanese Patent Laid-Open No. 09-146766)” proposes a method of changing the structure of an existing class using class code analysis information. Further, in the “program generation device (Japanese Patent Laid-Open No. 09-146766)”, a method for providing a program generation device with a small size has been proposed.
JP 09-146766 A

  However, in the case of the above prior art, although a method related to the integration of a plurality of classes has been proposed, the purpose of equivalent conversion of class diagrams is only to improve the maintainability of model drawings. The generated program is not intended to improve performance.

  In addition, in the case of the above prior art, for example, the purpose is to support model drawing refinement work, such as by extracting attributes and functions common to a plurality of classes and generating higher-level abstract classes. No mention is made of the performance of the program automatically generated from the resulting model drawing. Furthermore, in the case of the same document, only state transition information of a specific class is read, and the plurality of similar states are reduced to one state by reduction means, thereby reducing the size of the automatically generated program. Although a method is proposed, there is no mention of means for improving performance by integrating a plurality of classes and state diagrams having different responsibilities and automatically generating a program based on the result.

  As described above, the conventional object-oriented programming generation apparatus cannot integrate a plurality of classes and automatically generate a program using the integration result, and cannot solve the first and second problems. .

  On the other hand, in the case of the above solution studied by the applicant of the present application, if the class diagram is described with a smaller number of classes, the model drawing becomes difficult to understand, and the design drawing is easy to read and maintain. It contains the problem of losing the greatest advantage of directed analysis design.

  The present invention has been made in view of such problems, and an object thereof is to extract a plurality of classes that can be integrated from model diagram information input by a user and automatically generate a program from the result of integrating the classes. Thus, an object-oriented programming generation apparatus capable of realizing a reduction in memory capacity required for a generated program and an improvement in execution speed is provided.

  Another object of the present invention is to maintain the readability and maintainability of the model diagram by adopting a configuration that does not reflect the above-mentioned class integration result for the model diagram displayed to the user. An object of the present invention is to provide an object-oriented programming generator that realizes a configuration that does not impair the merit.

In order to achieve the above object, an object-oriented programming generating apparatus according to the present invention comprises the following arrangement. That is,
An object-oriented programming generator that executes object-oriented programming based on model information that represents the structure of software,
Model information storage means for storing the model information;
Class integrating means for integrating classes that can be integrated from the model information;
Class-integrated program generation means for generating an object-oriented program based on the model information in which classes are integrated in the class integration means;
Program display means for displaying a program generated by the post-class integration program generation means.

  According to the present invention, a plurality of classes that can be integrated are extracted from model diagram information input by a user, and a program is automatically generated from the result of integrating them, thereby reducing the memory capacity required for the generated program. In addition, it is possible to provide an object-oriented programming generation apparatus that can improve the execution speed.

  In addition, according to the present invention, the model diagram displayed to the user does not reflect the above-mentioned class integration result, so that the readability and maintainability of the model diagram are maintained, and the merit of the object-oriented analysis design is impaired. It is possible to provide an object-oriented programming generation device that realizes a configuration that does not exist.

  Hereinafter, embodiments of the present invention will be described in detail with reference to the accompanying drawings as necessary.

<Overall configuration of object-oriented programming generator>
FIG. 1 is a diagram showing an overall configuration of an object-oriented programming generating apparatus according to the present embodiment. In FIG. 1, reference numeral 101 denotes a CPU which accesses and controls devices 103 to 110 described below via a bus denoted by 102. Reference numeral 103 denotes a read-only memory (ROM) that can be accessed from the CPU 101 via the bus 102. In this embodiment, a processing program 103a for explaining the operation in detail and a parameter 103b used by the processing program 103a are stored. .

  Reference numeral 104 denotes a readable / writable memory (RAM). On the RAM 104, areas for storing model information created / changed by the processing program 103a, class integration result information, and a generation program (in order 104a and 104b). 104c) is secured.

  An input interface 105 receives an input made via an input device such as a keyboard, a button, a mouse, and a dial indicated by 106. Reference numeral 107 denotes an output interface, which displays / outputs data to the display medium 108a such as a CRT or LCD shown at 108, and to an output device 108b such as a printer or plotter. Reference numeral 109 denotes an external storage device interface for inputting / outputting data to / from an external storage device such as HD, FD, CD-ROM, MD, and CF shown at 110.

<Functional configuration of object-oriented programming generator>
FIG. 2 is a block diagram showing a functional configuration of the object-oriented programming generating apparatus according to the present embodiment. In the figure, reference numeral 201 denotes a model diagram input unit through which a user inputs model information such as a class diagram and a state diagram, and is realized by the input interface 105 and the input device 106.

  A model information storage unit 202 stores the model diagram information input by the model diagram input unit 201 on the object-oriented programming generation apparatus. The stored model information is stored in the RAM 104 via the bus 102.

  A model diagram display unit 203 displays a model diagram for the user based on the model information stored in the model information storage unit 202, and is realized by the output interface 107 and the display medium / output device.

  Reference numeral 204 denotes an input of model information stored in the model information storage unit 202 and a conversion rule for converting the model information into a program language such as C, C ++, Java (registered trademark), etc. This is a program automatic generation unit to be generated. This processing program (103 a) is stored in the ROM 103 and used via the bus 102.

  Reference numeral 205 denotes a program storage unit that stores a generation program generated by the automatic program generation unit 204 or the automatic program generation unit 211 after class integration described later on the object-oriented programming generation apparatus. The generated generation program is stored via the bus 102. Stored in the RAM 104.

  A program display unit 206 displays the generated program 104 c stored via the program storage unit 205, and is realized by the output interface 107 and the display medium / output device 108.

  Reference numeral 207 denotes an integrated class selection unit that automatically selects a class that can be integrated from model information stored in the model information storage unit 202. This processing program (103a) is stored in the ROM 103 and used via the bus 102. Is done.

  208 integrates a plurality of selected classes into one class based on the class information selected by the integrated class selection unit 207 and the model information input by the user stored in the model information storage unit 202. This is a class integration unit, and this processing program (103 a) is stored in the ROM 103 and used via the bus 102.

  209 is a state diagram integration unit that newly generates one state diagram by merging the state diagram information of each when two classes integrated by the class integration unit 208 are both active classes. This processing program (103 a) is stored in the ROM 103 and used via the bus 102.

  A class integration result storage unit 210 stores the result integrated by the class integration unit 208, and the stored class integration result information is stored in the RAM 104 via the bus 102.

  211 is operable by inputting class integration result information stored in the class integration result storage unit 210 and conversion rules for converting model information into a program language such as C, C ++, Java (registered trademark), and the like. This is a post-class integration program automatic generation unit that automatically generates a program. This processing program (103a) is stored in the ROM 103 and used via the bus.

  Reference numeral 212 denotes a program automatic generation unit 204 that automatically generates a program based on model information input by the user, and a post-class integration program automatic generation unit 211 that automatically generates a program based on class integration result information. This is an automatic program generation method selection unit that can be selected by the input interface 105 and the input device 106.

  In the object-oriented programming generating apparatus configured as described above, model information input by the user via the model diagram input unit 201 is stored in the model information storage unit 202. In the model information, first, a plurality of classes are selected by the integrated class selection unit 207, and the selected plurality of classes are integrated by the class integration unit 208 and the state diagram integration unit 209.

  The integrated result (class integration result information) is stored in the class integration result storage unit 210, and based on the information, the post-class integration post-program automatic generation unit 211 automatically generates a program with excellent performance. The automatically generated program is stored in the program storage unit 205 and displayed on the program display unit 206.

  Further, the model diagram displayed on the model diagram display unit 203 is always based on the model information input by the user stored in the model information storage unit 202. For this reason, in other words, the model information after class integration stored in the class integration result storage unit 210 is stored only in the object-oriented programming generation apparatus, and the model diagram displayed on the model diagram display unit 203 includes The configuration is not reflected. As a result, it is possible to enjoy the merits of object-oriented analysis and design while maintaining the readability and maintainability of the model diagram.

<Example of class diagram integration>
FIG. 14 is a diagram illustrating an example of integration of class diagrams. In the figure, 1401 and 1402 are a pair of classes determined to be integrated by the integrated class selection unit 207 among the model information input by the user through the model diagram input unit 201, 1403 and 1404 are the class integration unit 208 and the state The classes are integrated by the figure integration unit 209.

  For example, when Class B and Class C shown in 1401 are integrated, a class 1403 newly generated after integration has a class name (Class B Class C) obtained by concatenating the names of the classes before integration, and the attributes and functions defined are It is the merged definition of two classes before integration.

  In the case where Class D and Class F shown in 1402 are integrated, an integrated class 1404 is similarly generated.

<Procedure for generating object-oriented programming>
FIG. 3 is a flowchart showing a procedure for generating a program in the object-oriented programming apparatus according to the present embodiment. Hereinafter, it demonstrates along this flowchart.

  When the user inputs model information via the model diagram input unit 201 in step S301, the model information storage unit 202 stores the input model information on the object-oriented programming generation device in step S302.

  In step S303, it is determined by the input from the user whether the input of the model information has been completed. Specifically, if the input immediately before the user corresponds to an input indicating the end of the input of model information, such as an automatic program generation start command, it is determined that the input of the model information has ended. If it is determined in step S303 that the input of model information has been completed, the process proceeds to step S304. On the other hand, if it is determined that the input has not ended, the process returns to step S301.

  In step S304, based on the model information stored in step S302, the integrated class selection unit 207 selects a class that can be integrated, and the class integration unit 208 and the state diagram integration unit 209 perform class selection on the selected class. Perform the integration.

  In step S305, the program automatic generation unit 204 automatically generates a program based on the class integration result information generated in step S304.

  In step S306, the program display unit 206 displays the program automatically generated in step S305 on the output device.

  Through the above processing, classes are integrated based on the model information input by the user, and automatic generation of a program with excellent performance is realized using the integration result.

<Selectable Class and Integration Processing (Step S304)>
FIG. 4 is a flowchart showing a detailed algorithm for selecting and integrating classes that can be integrated in step S304.

  In step S401, the subsequent processing from step S402 to step S404 is repeated by the number of related information stored in the model information stored in the model information storage unit 202.

  In step S402, using the model information stored in the model information storage unit 202, the integrated class selecting unit 207 determines whether the currently selected class can be integrated. Here, if it is determined that the selected class can be integrated, the process proceeds to step S403. If it is determined that the selected class cannot be integrated, the process proceeds to step S405, and the processing from step S401 is repeated again. It is.

  In step S403, the class integration unit 208 and the state diagram integration unit 209 perform class integration for the classes determined to be integrated in step S402. In step S404, the class integration result storage unit 210 stores the result of the model information integrated in step S403 (class integration result information).

  Through the above processing, a class that can be integrated is selected from the model information input by the user, and an actual integration process is performed on the selected class. The class integration result information generated and stored by these processes is used for automatic generation of a program with excellent performance.

  As is clear from the above description, according to the object-oriented programming generating apparatus according to the present embodiment, the integrated class selecting unit that selects a plurality of classes that can be integrated from the model information, and the plurality selected by the integrated class selecting unit A class integration unit that integrates the classes into one class, and an automatic program generation unit after class integration that automatically generates a program based on the class integration result information generated by the class integration unit. Compared to a programming generation device, it is possible to automatically generate a program with a reduced memory capacity and excellent execution speed.

  Furthermore, the model diagram displayed to the user is configured not to reflect the above class integration result information, so that the readability and maintainability of the model diagram can be maintained and the merit of object-oriented analysis design can be enjoyed. .

  In the present embodiment, as a method for determining whether or not class integration is possible in the integrated class selection unit 207, whether or not class integration is possible is performed according to the multiplicity of each class. Multiplicity represents how many two classes (objects created from them) are related.

<Example of model information>
FIG. 5 shows a holding example of particularly related information between classes among the model information stored by the model information storage unit 202 of the object-oriented programming generating apparatus according to the present embodiment. This related information example corresponds to the model information input by the user shown in FIG.

  In FIG. 5, 501 and 503 indicate pairs of classes related to each other, and 502 and 504 indicate the multiplicity of the corresponding class on the 501 side and the multiplicity of the class on the 503 side.

<Class integration decision process>
FIG. 6 is a flowchart showing a detailed process flow of the class integration availability determination process in the object-oriented programming generating apparatus according to the present embodiment, which corresponds to step S402 in FIG. Hereinafter, the model information of FIG. 5 will be described as an example along the flowchart.

  In step S601, the target row already selected by the iterative process (step S401) is referred to, and the classes described in the “class 1” and “class 2” columns are registered as classes to be determined. In the example of FIG. 5, for example, in the case where the row indicated by 505 is a target row, Class A and Class B are registered as target classes for determination.

  In step S602, it is determined whether “multiplicity 1” is 1 by referring to the same target row as described above. If it is determined that “Multiplicity 1” is 1, the process proceeds to step S603. On the other hand, if it is determined that “Multiplicity 1” is not 1, the process proceeds to step S606, where it is determined that integration is not possible. In the example of FIG. 5, “Multiplicity 1” of the row indicated by 505 is *, and it is determined that Class A and Class B cannot be integrated at this time.

  In step S603, it is determined whether “multiplicity 2” is 1 by referring to the same target row as described above. If it is determined that “Multiplicity 2” is 1, the process proceeds to step S604, where it is determined that integration is possible. If it is determined that “Multiplicity 2” is not 1, the process proceeds to step S606. It is determined that integration is impossible.

  In step S604, this class determination process is exited by the EXIT process shown in step S605 while retaining the information of the class determined to be integrable, and the process returns to the class integration process (step S403).

  In step S606, based on the determination result that the integration is impossible, the EXIT process shown in step S607 is used to exit this determination process, and then the process returns to step S405 to continue the repetition process.

  Through the above processing, two classes that can be integrated are automatically selected from the model information input by the user, particularly determined based on the related information between classes and the information on the multiplicity thereof.

  As described above, according to the object-oriented programming generating apparatus according to the present embodiment, integration is possible by including the model information storage unit and the integrated class selection unit that store the related information between classes and the information on the multiplicity thereof. Multiple classes can be automatically extracted.

  In the present embodiment, as a class integration method in the class integration unit 208, processing is switched depending on whether or not each class is an active class.

<Example of model information>
FIG. 7 shows an example of holding class type information of classes among model information stored by the model information storage unit 202 of the object-oriented programming generating apparatus according to the present embodiment. This class type information example corresponds to the model information input by the user shown in FIG.

  In FIG. 7, reference numeral 701 denotes a class name described in the model diagram, and reference numeral 702 denotes a class type of each class. Here, the class type 702 has a state diagram in which an event is received depending on whether or not the corresponding class has a state diagram, and a change of its own state and a specific action are executed using this event as a trigger. It is divided into an active class and a passive class that does not receive an event and does not have a state diagram.

<Class integration processing>
FIG. 8 is a flowchart showing a detailed processing flow of the class integration processing in the object-oriented programming generating apparatus according to the present embodiment, which corresponds to step S403 in FIG. Hereinafter, the model information of FIG. 7 will be described as an example along the flowchart.

  In step S801, either one of the two classes already determined to be integrable in step S402 is selected as a target class.

  In step S802, based on the class type information stored in the model information storage unit 202, it is determined whether or not the target class is an active class. If it is determined that the target class is an active class, the process proceeds to step S803. On the other hand, if it is determined that the class is not an active class, the process proceeds to step S806.

  In step S803, a class that has not been selected in step S801 is selected from the two classes that have already been determined to be integrated in step S402, and set as a target class.

  In step S804, it is determined whether the target class is an active class using the same means as in the process of step S802. If it is determined that the target class is an active class, the process proceeds to step S805. If it is determined that the target class is not an active class, the process proceeds to step S806. In the example of FIG. 7, for example, when the two classes determined to be integratable in Step S402 are Class B and Class C, the determination in Step S802 and Step S804 is determined as the active class, and thus the process proceeds to Step S805. .

  In step S805, the state diagrams possessed by the two classes to be integrated are integrated using the state diagram integration unit 209. In step S <b> 806, the class definitions of the two classes to be integrated are integrated using the class integration unit 208.

  By executing the above processing, class integration processing including integration of active classes is realized.

<Description of state diagram integration processing>
FIG. 9 shows an embodiment of state diagram integration processing in this embodiment. In FIG. 9, reference numeral 901 denotes an example of a state diagram input by the user, which corresponds to the state diagram of Class B in the class diagram input by the user shown in FIG. Similarly, 902 corresponds to the state diagram possessed by Class C in the class diagram input by the user shown in FIG.

  Reference numerals 903 and 904 denote an example of holding state diagram information among model information stored by the model information storage unit 202. Here, 903 represents state diagram information possessed by Class B, and 904 represents state diagram information possessed by Class C.

  In this example, the column items in the table describe the events that can be received in the state diagram and all the states that can be taken in the row items. Each cell receives each event in each state. The process (action) and the transition destination state are described. This state diagram information holding method is also called a state transition table, which is a generally well-known state diagram information holding method.

  905 shows an example of state diagram information after integration in which the state diagram information 903 of Class B and the state diagram information 904 of Class C are integrated by the state diagram integration unit 209 and stored in the class integration result storage unit 210. .

  Reference numeral 906 denotes an example in which the state diagram after integration is actually described from the state diagram information 905 after integration. However, the state diagram 906 after the integration is not actually displayed on the model diagram display unit 203, and the state diagram information 905 after the integration is automatically generated by the program automatic generation unit 211 after class integration. It is used only as information.

<Flow of state diagram integration processing>
FIG. 10 is a flowchart showing a detailed procedure for realizing the state diagram integration processing (step S805). Hereinafter, the state diagram integration processing will be described with reference to FIG.

  In step S1001, two state diagram information to be integrated stored in the model information storage unit 202 is set as Table A and Table B, all events registered in this are extracted, and this is integrated into the state diagram information ( The event sequence α is newly set as Table C), and this Table C is stored in the class integration result storage unit 210. In the example of FIG. 9, an event sequence α having (eventB1, eventB2, eventC1) as elements is generated and stored as a new table C.

  In step S1002, the processes in subsequent steps S1003 to S1015 are repeated for the number of states described in the row item of Table A. In the example of FIG. 9, since the number of states described in the state diagram information 903 of Class B is 3, the number of repetitions is 3.

  In step S1003, a new state name A is extracted from Table A. Here, in the example of FIG. 9, “StateB1” is extracted. In step S1004, the processes in subsequent steps S1005 to S1014 are repeated for the number of states described in the row item of Table B. In the example of FIG. 9, since the number of states described in the class C state diagram information 904 is 2, the number of repetitions is 2.

  In step S1005, a new state name B is extracted from Table B. Here, in the example of FIG. 9, “State C1” is extracted. In step S1006, a new state name C is created by concatenating state name A and state name B ("state name A state name B") and described in table C by class integration result storage unit 210. In the example of FIG. 9, a new state name “StateB1StateC1” is created and described in Table C.

  In step S1007, the processes in subsequent steps S1008 to S1013 are repeated by the number of event sequences α described in Table C. In the example of FIG. 9, the number of elements in the event sequence α created in step S1001 is 3, so the number of repetitions is 3.

  In step S1008, a new event C is extracted from the event sequence α. Here, in the example of FIG. 9, “eventB1” is extracted.

  In step S1009, it is determined whether or not the event C is defined in the table A. If it is defined, the process proceeds to step S1010. If it is not defined, the process proceeds to step S1012 to continue the processing. As described above, since “eventB1” is defined in Table A in the example of FIG. 9, the process proceeds to step S1010.

  In step S1010, the action at the time of receiving event C in state name A is extracted from table A, and this action is transferred to the action at the time of receiving event A in state name C of table C. At this time, even if there is no action, the information is posted. In the example of FIG. 9, since it is found from the state diagram information 903 (Table A) of Class B that the action when “eventB1” is received in “StateB1” is “actionα”, this is posted.

  In step S1011, the transition destination state (state name D) at the time of receiving the event C in the state name A is extracted from the table A, and the name ("state name D state name B") concatenated with the state name B is displayed in the table C. Is transferred to the transition destination state when the event A is received in the state name C. At this time, when there is no transition destination state, that is, when it is not assumed that the event A is received with the state name A (for example, corresponds to the cell 907 in FIG. 9), the information is posted. In the example of FIG. 9, since it is found from the state diagram information 903 (Table A) of Class B that the transition destination state at the time of “eventB1” reception in “StateB1” is “StateB2”, this is linked to the name of “StateC1”. Then, “StateB2StateC1” is transcribed.

  In step S1012, the action at the time of receiving the event C in the state name B is extracted from the table B, and this action is transferred to the action at the time of receiving the event A in the state name C of the table C. At this time, even if there is no action, the information is posted.

  In step S1013, the transition destination state (state name D) at the time of receiving the event C in the state name B is extracted from the table B, and the name ("state name A state name D") concatenated with the state name A is displayed in the table C. Is transferred to the transition destination state when the event A is received in the state name C. At this time, if there is no transition destination state, the information is posted.

  Through the above processing, the state diagrams of the two classes to be integrated are integrated, and information of one new state diagram is stored in the class integration result storage unit 210.

<Specific example of state diagram integration processing>
FIG. 11 shows a specific example of part of model information stored by the model information storage unit 202 and part of information stored as a class integration result by the class definition integration processing (step S806). .

  In the figure, reference numeral 1101 denotes an example of holding related information between classes, which is equivalent to FIG. Reference numeral 1102 denotes an example of holding the integration result when the classes are integrated by the class integration unit 208 based on the relation information 1101 between the classes.

  Reference numeral 1103 denotes an example of holding class type information, which is equivalent to FIG. Reference numeral 1104 denotes an example of holding an integration result when a class is integrated by the class integration unit 208 based on the class type information 1103.

  Reference numeral 1105 denotes a holding example of class attribute information, and similarly 1107 denotes a holding example of class function information. This holding example is characterized in that each attribute and function defined in each class is set as one line and held as a list.

  Further, 1106 shows an example of holding the integration result when the class is integrated by the class integration unit 208 based on the class attribute information 1105 and similarly, 1108 is based on the function information 1107 of the class. Is. At this time, even if the classes are integrated, the attributes and functions defined in each class are unchanged, and the number of lines does not increase or decrease.

<Flow of class definition integration processing>
FIG. 12 is a flowchart showing a detailed procedure of the class definition integration processing (step S806). In the following, the class definition integration processing will be described with reference to this flowchart, taking b) class type information 1103 and c) class attribute information 1105 in FIG. 11 as an example.

  In step S1201, a class name after integration (“class A class B”) is created by concatenating the class names of two classes (“class A” and “class B”) selected by the integrated class selection unit 207. . Here, in the example of FIG. 11, it is assumed that Class B and Class C are selected, and the class name after integration is “Class B Class C”.

  In step S1202, the processes in subsequent steps S1203 to S1210 are repeated for the number of tables recorded in the model information storage unit 202.

  In step S1203, one new table is extracted from the model information storage unit 202 and is defined as a table A. Here, in the example of FIG. 11, it is assumed that the class type information 1103 has been extracted.

  In step S1204, the processes in subsequent steps S1205 to S1208 are repeated for the number of cells whose information is described in Table A. In the example of FIG. 11, the design information is described in a total of 12 cells in the class type information 1103, so the number of repetitions is 12.

  In step S1205, a new cell is extracted from Table A and is designated as cell A. Here, in the example of FIG. 11, it is assumed that a cell described as “Class B” is taken out.

  In step S1206, it is determined whether the information described in the cell A is equal to “class A”. If it is determined that they are equal, the process proceeds to step S1208. If it is determined that they are different, the process proceeds to step S1207. In the example of FIG. 11, it is determined that they are equal to each other, and the process proceeds to step S1208.

  In step S1207, it is determined whether the information described in the cell A is equal to “class B”. If it is determined that they are equal, the process proceeds to step S1208. If it is determined that they are different, the process proceeds to step S1209.

  In step S1208, the information of cell A is replaced with “class A class B”. In the example of FIG. 11, the information “Class B” is replaced with “Class B Class C”.

  In step S1210, duplicate or unnecessary rows in table A are deleted. In the example of FIG. 11, since the information related to “ClassBCClassC” and the information related to “ClassDCclassF” are respectively duplicated, the information is deleted. Thereby, the integration result 1104 of the class type information is obtained, and this information is stored in the object-oriented programming generating apparatus by the class integration result storage unit 210.

  Through the above processing, the definitions of the two classes to be integrated are integrated, and by combining with the integration processing of the state diagram, integration processing of all classes including integration of active classes is realized.

  As is clear from the above description, the object-oriented programming generating apparatus according to the present embodiment is characterized in that a class newly integrated in the class integration unit is expressed by merging class definitions before integration. In particular, when integrating active classes that hold state diagrams, by having a state diagram integration unit that newly generates one integrated state diagram from the state diagrams of the two classes, Integration is possible, and it is possible to automatically generate a program with a small memory capacity and excellent execution speed.

[Other Embodiments]
In the above embodiment, the integration process is performed for all classes determined to be integrated by the integrated class selection unit. However, the present invention is not particularly limited to this, and the class integration process is not limited to this. The user may be allowed to select execution / omission.

<Procedure for generating object-oriented programming>
FIG. 13 is a flowchart showing a procedure for generating a program in the object-oriented programming generating apparatus according to the present embodiment. Hereinafter, it demonstrates along this flowchart.

  In step S <b> 1301, the user inputs model information through the model diagram input unit 201.

  In step S1302, the model information input in step S1301 is stored on the object-oriented programming generator.

  In step S1303, it is determined by input from the user whether input of model information has been completed. Specifically, if the input immediately before the user corresponds to an input indicating the end of the input of model information, such as an automatic program generation start command, it is determined that the input of the model information has ended. If it is determined that the input of the model information has been completed, the process proceeds to step S1304. If not, the process returns to step S1301.

  In step S1304, the automatic program generation method selection unit 212 executes class integration processing and automatically generates a program using the result, or is stored in the model information storage unit 202 without performing integration processing. The user selects whether to automatically generate a program using existing model information.

  In step S1305, it is determined whether execution of class integration processing has been selected by the processing in step S1304. If it is determined that it has been selected, the process proceeds to step S1306. If it is determined that it has not been selected, the process proceeds to step S1308.

  In step S1306, a class that can be integrated is selected based on the model information stored in step S1302, and class integration processing is executed for the selected class.

  In step S1307, the program is automatically generated based on the class integration result information generated by the process of step S1306.

  In step S1308, a program is automatically generated based on the model information stored in the object-oriented programming generation apparatus by the processing in step S1302.

  In step S1309, the program automatically generated by the process of step S1307 or the process of step S1308 is displayed on the output device 108b.

  Through the above processing, a program automatic generation unit that automatically generates a program based on the model information input by the user stored in the model information storage unit 202, and a class integration stored in the class integration result storage unit 210 are also used. The user can arbitrarily select and use a post-class integration program automatic generation unit that automatically generates a program based on the result information.

  Note that the present invention can be applied to a system including a plurality of devices (for example, a host computer, an interface device, a reader, and a printer), and a device (for example, a copying machine and a facsimile device) including a single device. You may apply to.

  Another object of the present invention is to supply a storage medium storing software program codes for implementing the functions of the above-described embodiments to a system or apparatus, and the computer (or CPU or MPU) of the system or apparatus stores the storage medium. Needless to say, this can also be achieved by reading and executing the program code stored in the.

  In this case, the program code itself read from the storage medium realizes the functions of the above-described embodiments, and the storage medium storing the program code constitutes the present invention.

  As a storage medium for supplying the program code, for example, a floppy (registered trademark) disk, hard disk, optical disk, magneto-optical disk, CD-ROM, CD-R, magnetic tape, nonvolatile memory card, ROM, or the like is used. be able to.

  Further, by executing the program code read by the computer, not only the functions of the above-described embodiments are realized, but also an OS (operating system) operating on the computer based on the instruction of the program code. It goes without saying that a case where the function of the above-described embodiment is realized by performing part or all of the actual processing and the processing is included.

  Further, after the program code read from the storage medium is written into a memory provided in a function expansion board inserted into the computer or a function expansion unit connected to the computer, the function expansion is performed based on the instruction of the program code. It goes without saying that the CPU or the like provided in the board or the function expansion unit performs part or all of the actual processing, and the functions of the above-described embodiments are realized by the processing.

1 is a diagram illustrating an overall configuration of an object-oriented programming generating apparatus according to an embodiment of the present invention. It is a block diagram which shows the function structure of the object-oriented programming generator concerning one Embodiment of this invention. It is a flowchart which shows the procedure for the program production | generation in the object-oriented programming apparatus concerning one Embodiment of this invention. It is a flowchart which shows the detailed algorithm of selection of the class which can be integrated, and an integration process. It is the figure which showed the example of holding | maintaining the relevant information especially between classes among the model information memorize | stored by the model information storage part of the object-oriented programming generation apparatus concerning one Embodiment of this invention. It is a flowchart which shows the flow of the detailed process of the class integration possibility determination process in the object-oriented programming generation apparatus concerning one Embodiment of this invention. It is the figure which showed the example of hold | maintaining especially the class classification information of a class among the model information memorize | stored by the model information storage part of the object-oriented programming generator concerning one Embodiment of this invention. It is a flowchart which shows the flow of a detailed process of the integration process of the class in the object-oriented programming generator concerning one Embodiment of this invention. In the object-oriented programming generation apparatus concerning one Embodiment of this invention, it is the figure which showed the specific example of the information stored as a process result of the integration process of a state diagram. It is a flowchart which shows the detailed procedure of the integration process of a state diagram in the object-oriented programming production | generation apparatus concerning one Embodiment of this invention. It is the figure which showed the specific example of a part of model information memorize | stored by a model information storage part, and a part of information stored as a class integration result by the integration process of the said class definition. It is a flowchart which shows the detailed procedure of the integration process of the class definition in the object-oriented programming generation apparatus concerning one Embodiment of this invention. It is a flowchart which shows the procedure for the program production | generation in the object-oriented programming apparatus concerning other embodiment of this invention. It is a figure which shows the example of integration of a class diagram.

Explanation of symbols

201: Model diagram input unit 202: Model information storage unit 203: Model diagram display unit 204: Program automatic generation unit 205: Program storage unit 206: Program display unit 207: Integrated class selection unit 208: Class integration unit 209: State diagram integration Unit 210: Class integration result storage unit 211: Automatic program generation unit after class integration 212: Automatic program generation method selection unit

Claims (12)

An object-oriented programming generator that executes object-oriented programming based on model information that represents the structure of software,
Model information storage means for storing the model information;
Class integrating means for integrating classes that can be integrated from the model information;
Class-integrated program generation means for generating an object-oriented program based on the model information in which classes are integrated in the class integration means;
An object-oriented programming generation apparatus comprising: program display means for displaying a program generated by the class integration post-program generation means. 2. The object-oriented programming generating apparatus according to claim 1, further comprising model information display means for displaying the model information stored by the model information storage means. Program generation means for generating an object-oriented program based on the model information stored by the model information storage means;
2. The object-oriented programming generation apparatus according to claim 1, wherein, based on an instruction from a user, the class integration unit to be integrated and the program generation unit are switched and executed to generate the program. The class integration means includes
2. The object-oriented programming generation apparatus according to claim 1, wherein whether or not the classes can be integrated is determined based on information related to classes and multiplicity information. 2. The state diagram integration unit that integrates the state diagrams of the classes when the classes integrated by the class integration unit are active classes having state diagrams. The object-oriented programming generator described. An information processing method in an object-oriented programming generation device that executes object-oriented programming based on model information that represents the structure of software,
A model information storage step of storing the model information in a storage means;
A class integration process for integrating classes that can be integrated from the model information;
A class-integrated program generation step for generating an object-oriented program based on the model information in which the classes are integrated in the class integration step;
A program display step of displaying the program generated in the post-class integration program generation step. The information processing method according to claim 6, further comprising a model information display step of displaying the model information stored in the storage unit by the model information storage step. A program generation step of generating an object-oriented program based on the model information stored in the storage means by the model information storage step;
The information processing method according to claim 6, wherein the program is generated by switching and executing the class integration step to be integrated and the program generation step based on an instruction from a user. The class integration process includes
7. The information processing method according to claim 6, wherein whether or not the classes can be integrated is determined based on the relation information between classes and the multiplicity information. The class diagram integration step further comprising a state diagram integration step of integrating the state diagrams included in each class when the classes integrated in the class integration step are active classes having state diagrams. The information processing method described. The storage medium which stored the control program for implement | achieving the information processing method of any one of Claim 6 thru | or 10 with a computer. A control program for realizing the information processing method according to any one of claims 6 to 10 by a computer.

Images