JPH04180127A - Method for transforming class into file - Google Patents

Abstract

PURPOSE:To improve the retrieving speed for the definition contents when the object directing software is applied to an exchange system by storing the definition contents of more significant classes that are not duplicated with each other in addition to the definition contents proper to a certain class when this class is transformed into a file. CONSTITUTION:The classes are transformed into files as follows with the software used in an exchange system which is formed based on the direction of an object. That is, if a class A 11 more significant than a class B 13 exists when the class B 13 is transformed into a file, the definition contents proper to the class B 13 are extracted and then the definition contents of the class A 11 which are not duplicate with each other are taken out. These extracted contents are stored in a program C 15 in the form of a file. Thus the program C 15 storing the definition contents of the class B 13 is retrieved by an access at a high speed even with the definition contents of the class A 11 in a system execution state.

Description

DETAILED DESCRIPTION OF THE INVENTION (Field of Industrial Application) The present invention relates to a method of creating a class file in object-oriented software for an exchange system such as a PBX.

(Prior Art) Currently, development of software for switching systems requires enormous cost and time. The same applies when adding new functions or services to already developed exchange system software.

Therefore, in order to improve the ability to develop software for exchange systems, it is necessary to store software as reusable software components. By reusing the componentized software or adding new software components, new software components can be produced with a reduced amount of design, and software productivity can be improved.

On the other hand, various software exchange systems must be constructed by combining software components. In order to construct an exchange system, the exchange system μ must be modeled as a relationship between "elements" that is easier for people to understand. Therefore, software components can be used as a function-oriented method (Function-oriented method) as an exchange system model.
ctionOriented Method) and object oriented method (Object Oriented Method) and object oriented method (Object Oriented M
There is a method. The former method describes the functions that the system should have as FE (Functional Elements).
t), a series of FE groups are defined as F C (Fu
It consists of the work of defining a functional component. The latter method is based on the target users, terminals, trunks, calls,
Routes and the like are defined as object types (classes), and FEs and FCs are considered to be encapsulated in objects that are the entities (instances) of each class.

However, if software components are defined in accordance with FE or FC, the size of the software components will be too small and have little reusability value, and the task of assembling a system using software components will become significantly more complicated and complicated. has. For this reason, it is necessary to define software parts and products in correspondence with "classes" and "objects" defined in an object-oriented method.Here, objects refer to information and procedures for handling that information. (methods), and the only way to access an object is to send a message to that object, and the object itself interprets the message and executes the corresponding function. A class defines information managed by an object and procedures for individual messages.

Class inheritance is used to improve the productivity of object-oriented software for switching systems.

Inheritance is a mechanism that allows propositions to be inherited between class definitions, and by providing definition differences (additions, replacements) based on the definitions of other classes, new classes can be created. can be made. Therefore, the inheritance is class A (superclass A) and class B.
By inputting (subclass B), we can obtain class B, which inherits superclass A, as the output. This obtained class B contains all the declarations and class definition operations (
method) will be inherited. However, as shown in Figure 2, class B (subclass B), which is a lower class, has class-specific definition contents (declarations, methods, etc.) written therein, as well as the name of the inherited superclass A. However, the specific definition of superclass A is not written. Incidentally, FIG. 2 is an explanatory diagram showing the relationship between a superclass and a subclass that inherits the superclass.

Conventionally, when creating a file for a class, class B, which is a lower class (subclass), and class A, which is an upper class (superclass) from which it inherits, are each filed separately.

Therefore, when object-oriented software for exchange systems is applied to an exchange system, when a system program is executed, a file of class B, which is a lower class, is accessed, and a corresponding method is searched for, for example, in class B of that file. However, if the applicable method is not found, the file of class A, which is an inherited upper class, is accessed, and the applicable method is searched and extracted from class A in that file. At this time, for the first time, the corresponding method in the definition content of class A, which is a higher class, is substantially inherited by class B, which is a lower class. In other words, this is dynamic inheritance that occurs when a program is executed.

Note that a class definition consists of a class name declaration, an instance declaration, a variable declaration, and a method i (i=1 to n) definition. In addition, as related literature on class inheritance, ``Evolution of Object-Oriented Programming Software Development Techniques'' (especially Section 5, Inheritance: How to Implement It (P. 93-P. 99)), Author:
B, J Cox, supervising translator: Maeyo no Mori, publisher: Trapan.

(Problem to be Solved by the Invention) In the conventional class filing method described above, even if a lower class inherits a higher class, only the name of the inherited higher class is written in the lower class. During operation, the file of the lower class is accessed, and if, for example, there is no corresponding method, the file of the higher class that is the inheritance source is accessed, and the definition contents of the higher class are searched.

Therefore, when applying conventional object-oriented software to a large-scale exchange system, the conventional method of creating a class file has the following problems.

(1) Access the file of the lower class, search for the applicable method in the lower class, and if the applicable method is not found, then access the file of the higher class that is the inheritance source, and search for the applicable method in the lower class. Searching for a method means accessing two files, which takes extra time. Therefore, the speed when searching for definition contents of classes such as methods becomes slow.

(2) Variables with the same name of different types (for example, integer type variable a and character type variable a) or memory member configuration (variable name in the structure) with the same tag name (structure name) If there are structures etc. with different configurations, the lower class and its upper class are stored in separate memory files, so the lower class (subclass) and the upper class (superclass) will have different interpretations, and the lower class If the consistency between the program in the lower class and the program in the upper class is not good, the program may behave abnormally when the program is executed and the system will not work. If the classes are made into separate files, the program will not be consistent and its reliability will decrease.

SUMMARY OF THE INVENTION Therefore, an object of the present invention is to apply object-oriented software for an exchange system to an exchange system, and to create a class file that can be quickly searched for even the definition contents of an inherited upper class when the system is executed, and that maintains high reliability. The objective is to provide a method for

(Means for Solving the Problems) The method for creating a class file of the present invention is a method for creating a class file in software for an exchange system created based on a concept called object-oriented, which integrates information and procedures for handling that information. When creating a file, if there is an inherited upper class name in that one class, extract the unique definition content of the one class, and then extract the definition that has already been extracted from the definition content of the inherited upper class. Definition contents that do not overlap with the contents are extracted, and these extracted definition contents are stored as a file in memory as the definition contents of the one class.

(For use) In the method of creating a class file according to the present invention, when a class is created as a file, if there is a name of a superior class inherited by that one class, the unique definition contents of said one class are saved. First, we take out the definition contents of the upper class that is the inheritance source, and then we take out the definition contents that are not duplicated among the definition contents of the upper class that is the inheritance source, and these extracted definition contents are stored as a file in memory as the definition contents of the first class, so that the exchange system Applying object-oriented software to an exchange system, when the system is running, it is possible to quickly search for the definition contents of the inherited upper class by accessing the same file that stores the definition contents of the first class. , high reliability can be maintained.

(Example) The present invention provides a class (a class inheriting a superclass) in object-oriented software for an exchange system.
This relates to how to create a file.

An embodiment of the present invention will be described using FIG. 1.

FIG. 1 is an explanatory diagram showing an embodiment of the method of creating a class file according to the present invention.

In the figure, reference numeral 11 denotes class A as a super class (upper class) stored in a memory such as a floppy disk, and this class All contains definition contents (declarations, variables, etc.) of class A.

methods, etc.) are written. In addition, 13 is a class B as a subclass (lower class) stored in memory such as a Flotsbee disk, and this class 813 includes definition contents specific to class B (declarations, variables, methods, etc.) and inheritance. The name of the super class (class A) that was created is written. Note that class A and class B are programs written in an object-oriented programming language. 15 is class B and its inheritance source super class A.
The definition contents extracted from (class A) so as not to overlap are divided into definition contents common to class A and class B and definition contents not common to class A and class B, and a program written in a general-purpose programming language (C language) For convenience, it will be referred to as program C), and this program C is stored in memory. By inputting this program C into a compiler, it is developed into a machine language program and program A
, B. By concatenating and editing other programs (libraries, etc.) referenced by , a computer executable program (load module) is created and stored on the floppy disk 17. Incidentally, numeral 17 is a floppy disk serving as a memory, and a class B file is created on this floppy disk 17.

Next, the creation of a file for class B, which inherits super class A, will be explained. First, program C is created by inputting class B and superclass A, which is its inheritance source, to a precompiler. Here, the bricompiler is a device that converts a source program written in an object-oriented language into a source program in a general-purpose programming language (C language).

Therefore, if you connect the memory that stores class A and the memory that stores class B to the input side of the bricompiler,
The precompiler first reads class B that is stored in memory and is to be converted into a file, and then reads the declaration that is the definition specific to class B.

The precompiler stores variables, methods, etc. in internal memory, and then reads the superclasses that class B inherits from in the order of inheritance.Here, since superclass A is the only inheritance source, only class A is read. ), and compares it with the information that has already been read and stored in internal memory to check whether there are any inconsistencies in the definition contents of the read variables, methods, structure declarations, etc. (whether there are any duplications). while storing unique ones in internal memory.

In this case, if a method, variable, declaration, etc. with the same name as the definition of class B appears in the definition of superclass A, the precompiler will give priority to the one of class B, which is a lower class, and store it in internal memory. do. Then, after completing the above processing for all of the superclasses that are the inheritance source (here, only class A is referred to as the only superclass that is the inheritance source), the precompiler will:
A C language program C15 is created by dividing the definition contents stored in the internal memory into definition contents common to class B and super class A and definition contents not common, and this is stored in the external memory.

Next, the C'PU stores the definition contents (
The definition contents of class B extracted without duplication and the definition contents of its inheritance source super class A) are extracted and converted into a file as the definition contents of class B in a memory, for example, the floppy disk 17.

As a result, the definition contents of class B stored in a file on the floppy disk 17 include not only the name of superclass A but also the definition contents for that superclass.

As described above, in object-oriented software for exchange systems, if a class that inherits a superclass is created as a file, the definition contents (methods, declarations, variables, etc.) of the inherited superclass will also be inherited when the file is created. ing. Therefore, when object-oriented software for exchange systems is applied to an exchange system, if the file on the floppy disk 17 that stores the definition contents of class B is accessed when the system is executed, the definition contents of super class A, which is the inheritance source of class B, can be accessed. are also stored in the same file, so the corresponding definition contents of super class A can also be retrieved by simply searching within the same file.

Therefore, when the system is executed, there is no need to carry out inheritance processing for superclass A, which is the inheritance source, as in the past.
Accordingly, the search speed for the relevant definition content can be increased compared to the conventional method. Also, when creating a class B file,
Since the consistency of inheritance is checked in advance to ensure that the definition contents of the super class A that is the inheritance source do not overlap with the definition contents specific to class B, when the exchange system built using object-oriented software is executed, the program will be It is expected that the reliability will be improved without causing such abnormal operation.

In this embodiment, class B inherits only superclass A, but the present invention can be similarly applied even if class B inherits multiple superclasses. In this case, the definition contents of class B stored in a file in the memory include definition contents unique to class B as well as definition contents of multiple superclasses from which it is inherited. However, the definition contents of the plurality of super classes stored in files are the definition contents extracted as described in this embodiment so as not to overlap in the order of inheritance.

The present invention is not limited to this embodiment, and various applications and modifications can be made without departing from the gist of the present invention.

(Effects of the Invention) As described above, according to the present invention, the following effects can be obtained.

(1) In the same file, as the definition content of one class,
It also includes the definition contents of the superclass that inherited it, so when object-oriented software for exchange systems is applied to exchange systems (including large-scale exchange systems),
When the system is executed, by simply searching in the same file that stores the definition contents of one class, the corresponding definition contents of the upper class of the inheritance source can also be retrieved. It is no longer necessary to carry out inheritance processing for the upper class, and the search speed for the corresponding definition contents can be increased accordingly compared to the conventional method.

(2) When creating a file for one class, the consistency of inheritance is checked in advance to ensure that the definition content of the upper class that is the inheritance source does not overlap with the definition content that has already been extracted, so the exchange built using object-oriented software system(
When executing a program (including a large-scale exchange system), the program does not operate abnormally as in the past, and reliability can be improved.

[Brief explanation of drawings]

FIG. 1 is an explanatory diagram showing an embodiment of the method of creating a class file according to the present invention, and FIG. 2 is an explanatory diagram showing the relationship between a super class and a subclass. 11...Class A, 13...Class B, 15...
Program C3 17...Floppy disk. Patent Applicant Oki Electric Industry Co., Ltd. Consistent Example of File Creation Method for the Class of the Present Invention No. 1
figure

Claims (1)

[Claims] In software for exchange systems that is created based on a concept called object-oriented, which integrates information and procedures for handling that information, when one class is converted into a file, there is a superclass name that is inherited by that one class. In this case, extract the unique definition content of the first class, then extract the definition content of the inherited higher class that does not overlap with the already extracted definition content, and check the consistency of the duplicate definition content. A method for creating a class file, characterized in that the extracted definition contents are filed and stored in memory as the definition contents of the one class.