JPH06214790A - Object direction data processor - Google Patents

Abstract

PURPOSE:To respectively combine a method designated by means of a class with used instance data so as to be properly changeable by providing both a class schemer for describing the method ID of the method fetched inside a its own class and an instance schemer for changeably fetching instance data. CONSTITUTION:The metaclass method 311 prepares desired individual classes. The class schemer 312 corresponds to some one of the prepared classes, describes method ID regarding the various kinds of methods which are changeably fetched to the class and also describes the sequence schemer instructing order relation, etc., by which the various kinds of methods are utilized. In an instance schemer 316, the class name of a class to which its own instance schemer 316 is related is described and also instance data which utilized method requires is described with respective method IDs linked.

Description

Detailed Description of the Invention

[0001]

BACKGROUND OF THE INVENTION 1. Field of the Invention In the present invention, an object management unit extracts individual objects and appropriately combines the individual objects so as to execute a process. The present invention relates to an object-oriented data processing device that enables a free combination of the relationships.

[0002]

2. Description of the Related Art FIG. 13 is a diagram for explaining the advantage of encapsulating an object as in the case of the present invention. For example, taking the execution processing data 214 as an example, as shown in FIG. 13A, the execution processing data is a series of instructions (or a group of instructions).
250 is given as serialized in processing order. Some of these commands (or a group of commands) 250 collectively form a processing unit 251 that executes a predetermined process, that is, performs a certain behavior.

Therefore, the execution processing data shown in FIG. 13A can be regarded as serialized processing units 251 that perform a certain behavior as shown in FIG. 13B. The serialized execution process data 214 as shown in FIG. 13B is for performing a specific operation as a whole. Therefore, the execution process data 214 for performing another specific process is given as another execution process data in which the processing units 251 having different combinations are connected.

As a large number of existing processing units 251 exhibiting different behaviors are obtained, as shown in FIG. 13C, the individual processing units 251 are integrated under a predetermined method M as required. By doing so, it is possible to obtain the same operation data 214 as shown in FIG. 13B.

The relationship among objects, object commands, and object parts will be described in advance. Less than,
More specifically, the relationship between the object, the object command, and the object part according to the present invention will be described.

FIG. 14 shows an example of modeling in the real world, for example, a company department. In FIG. 14,
In the frame representing “employee”, for example, there is a “secretary” belonging to “job type = 1”, a “leader” belonging to “job type = 2”, and a “job type = 3”. There are “workers”. The "employee" frame belongs to the "team" frame.

"Leader" is related to "team" under the relationship of "team leader", and "worker" is related to "worker / machine" within the framework of "work unit". Related to "machine".

Further, "team" and "machine" are related under the relation of "machine / workplace", and "worker" and "machine" are also related under the relation of "machine / worker". Related by. Furthermore, “employee” is related to “department” under the relationship of “department / employee”.

Furthermore, “employee” is “employee / attribute”.
Under the relationship of "affiliation", the "work unit" is related to "part" under the relationship of "work unit / part".

Furthermore, (1) "department" is related to the object "department name" and object "dollar", and (2) "team" is related to the object "name" by the team identification number. , Related to the object "employee number" by job type, related to the object "code name" or object "surname" by name, related to the object "dollar" by salary, and the object "dollar" by average salary "," The object "number" by the average number of departments
(3) "Secretary" is related to object "number" by typing speed, (4) "Affiliation" is related to object "name" by name, and object "year" by age. Related,
(5) "Part" is related to the object "Part number" and object "Dollar", (6) "Work unit / part" is related to the object "Number" by quantity, (7) "Work unit" Is related to the object "time" by the required time, (8) "machine" is related to the object "machine number", the object "dollar" and the object "machine name", and (9) "machine / labor". Is associated with the object "time" by the time of use.

In the model shown in FIG. 14, generally, for example, when the circle mark is “behavior” (or method), the square mark is “data”, and the diamond mark is “relationship”, the model shown in FIG.
It can be represented as shown in FIG. That is, (1) method a and data I are combined to serve as one larger data IV, and (2) methods b and c are related to data II by the relationship α, and one larger data IV Acts as V, and (3) methods c and d are related to data III by the relation β, and one larger data
Acts as VI, and (4) method e is related to data IV, V and VI by the relation γ, and one larger data
It acts like VII, and can be represented in the form of being grouped together, entangled, and forming a larger group.

The circles, corners and diamonds shown in FIG. 15 can be handled as objects one by one. Considering a collection such as method a and data I shown in FIG. 15, consider encapsulation as shown in FIG. 16 (A). A hole formed above the capsule in FIG. 16A indicates that a message can be communicated. If the upper hole of the capsule shown in FIG. 16 (A) is blocked, it corresponds to data IV which is a collection such as method a and data I shown in FIG. The data is shown at the left end of FIG. FIG.
When the method M is added to the data D at the left end of (B) to obtain a compound object, the data becomes the data shown in the center of FIG. When the object is obtained, it becomes the one shown at the right end of FIG. The composite thus formed corresponds to FIG. 13 (C).

The manner in which the compounding is performed is not limited to the form shown in FIG. 16 (B). For example, when the data D in the leftmost object in FIG. 16C is replaced with an object composed of a method and data,
(C) It is the second one from the left end. In this case, message passing is required between the illustrated method M ₁ and data D _1, and 3 from the left end of FIG. 16C.
The method M ₁ becomes one object as shown in the second. As a result, the object C and the object B exist in the object C, and the message passing exists between the object A and the object B.

Furthermore, in the illustrated object B
Method M is object B₁And on object B
Data D in object B₂Then, Fig. 16
(C) In the object B, the object
Ject B₁And object B ₂And exist,
Bect B₁And object B₂Between the message
The structure is such that there is a thing.

As described above, so-called atomic objects, which will be described later, are compounded into, for example, capsule objects, the capsule objects are compounded into, for example, event objects, and the event objects are compounded. For example, the system
It becomes an object ... It is compounded one after another.

In the above, what is shown as the data D is generally a plurality of units to be processed, and what is shown as the method M is how to use the plurality of units to be processed. It may be considered as information or a group of information to be instructed. In FIG. 16, what is expressed as an object is an individual “processing target unit” or a “processing target unit” that can be handled as a single integrated processing target unit by combining the individual processing target units.

As shown in FIG. 15, the individual objects I, II, III are respectively larger objects IV, V,
Form part of a VI. In addition, the object IV, V, VI
Also forms part of the larger Object VII.
In other words, objects IV, V and VI are objects respectively.
Seen from VII, “Is ...
Relationships represented by “is (a)” and “part of (part)
-Of) ".

When considering the illustrated objects I, II, and III as the minimum units, these objects I, II, and III are atomic objects. When they are collected, what is called a capsule object is formed, when those capsule objects are collected, what is called an event object is formed, and a larger system object is formed.

Each of these objects is generically called a composite object. The atomic object is also included in the concept of the compound object.
However, the atomic object is an object of the minimum unit as described above, and when it is generally called a compound object or simply an object, it may be considered that an atomic object that exists as a non-decomposable simple substance like the atomic object is excluded.

The encapsulated object described above is generally an encapsulation of the composite object. The individual objects can be represented by the following model. That is, FIG. 17 is an explanatory diagram for modeling and grasping the object.

Some things in the real world, such as photographs, can be identified by the name representing the photograph and the nature of what the photograph is like, for example, who photographed what time. it can. And the picture is
(I) A command as a name to specify the photograph, and (i
i) The entity of the picture (entity data) consisting of so-called black and white dots, and (iii) the nature of the photograph, the place where the entity of the picture is stored, and the like It can be modeled and grasped with a link that describes the relationship between multiple people who are present.

The individual objects described above can also be modeled and represented by commands, links, and entity data, as shown in FIG. Figure 1
FIG. 8 is a diagram for explaining the function of the modeled object. As shown on the left side of FIG. 18, an object can be represented by a command, a link, and entity data, and it can be considered that dot data as shown is given to the entity data. The above-mentioned capsule object, event object, and system object are generally other objects X, as entity data, as shown on the right side of FIG.
A description specifying Y and Z is given, and the object is associated with the other object X, Y, Z and the other object X,
The Y, Z entity data x, y, z are used.

The inventors of the present application filed Japanese Patent Application No. 4-
In No. 236641, it was proposed to grasp an object part describing meta data together with entity data as one processing unit.

FIG. 19 shows a processing mode for handling an object. Reference numeral 201 in the drawing denotes an object command, which is the same as the command shown in FIGS. 17 and 18. That is, it is a name used to specify the object. Reference numeral 202 is meta data, which is shown in FIG.
It can be considered to correspond to the link shown in FIG. That is, it is the data (explanatory text of the actual data) that describes the actual data, and the names, comments, commands, etc., and further the above-mentioned "is-a" hierarchical relation and "part-of" hierarchical relation, The sequence relationship between objects is described. The comment is a descriptive sentence for understanding the meaning of the actual data when explaining the actual data, and is a schematic flowchart, a detailed flowchart, and a source program. Reference numeral 203 is the entity data shown in FIGS. 17 and 18, and the processing execution program is treated as one of the actual data.

Reference numeral 204 in FIG. 19 is a command / link processing unit, which is also called a directory processing unit. When one new object is created, the command that is the name of the object (hereinafter, object.
Command)) and set the actual data 203
The storage location of the meta data 202 is allocated, and the command link table is created. At this time, the type of the object is determined and the size is determined. Then, using the command link table, a combination of the meta data 202 and the actual data (entity data) 203 can be input / output. It also performs input / output processing. The combination is named an object part. Then, the object part 206 can be specified using the object command.

[0026]

As described above, the grouped objects or compound objects are combined in a changeable manner as needed, and the desired processing is executed.

To obtain such a changeable combination, a mechanism for enabling the combination is required. That is, in a class and an instance that are generally used in the field of this kind of data processing system, the methods specified in the class can be combined appropriately and the instance data used can be combined appropriately. A mechanism to do so is required.

It is an object of the present invention to make it possible to appropriately change the combination of a method designated by a class and instance data used in an object-oriented data processing device.

[0029]

FIG. 1 is a block diagram showing the principle of the present invention. Reference numeral 203 in the figure is actual data (entity data), and 204 is a command link processing unit, which corresponds to that shown in FIG.

Reference numeral 300 shown in FIG. 1 is a conceptual schema, which is a conceptual representation of the information hierarchical relationship considered in the present invention. Reference numeral 301 is a metaclass, which is prepared in the present invention so as to be able to generate a class into which a method can be appropriately changed.

Reference numeral 302 denotes a class, and if the class concerned is a passenger car, it is considered that various methods relating to a passenger car are variably incorporated and handled as one class. Reference numeral 303 is an instance, for example, a class 30 for passenger cars
This is a drawing showing a processing program created for a specific passenger car by giving individual specific data to the generic name data used by each method incorporated in 2.

Reference numeral 310 is an internal schema, which corresponds to the above-mentioned conceptual schema 300 and is configured inside the data processing apparatus. Reference numeral 311 is a metaclass method, which is a method for generating a desired individual class. Reference numeral 31
Reference numeral 2 denotes a class schema, which corresponds to one generated class and describes method IDs of various methods that are changeably incorporated into the class, and the various methods are used. Describes the sequence schema that indicates the order relationship.

Reference numerals 313, 314, 315 ... Represent methods, and each method 313, 314, 315
Are linked with the method ID on the class schema 312 to form a class method group used in the class.

Reference numeral 316 is an instance schema. In the instance schema 316, the class name of the class (for example, 312) related to the own instance schema 316 is described, and the instance data required by the method used in the class (the above-mentioned entity (May be considered as data 203) is described by linking with each method ID.

Reference numeral 320 denotes pop-up data, which is extracted and written as instance data in the instance schema 316 from the pop-up data.

[0036]

For example, when an attempt is made to generate a class 302 relating to a passenger car and an instance 303 related to the class, the following process is performed.

The person (operator) who wants to generate the various methods (think that these methods already exist) that come to mind at that time are necessary for generating the class. Consider as a method. The considered thing may be considered as the illustrated metaclass 301.

The operator inputs to the metaclass method 311 the generation of a class related to a passenger car, and also inputs the various method names that come to mind to the metaclass method 311.

Correspondingly, metaclass method 3
Reference numeral 11 describes on the class schema 312 that it is a class related to passenger cars, and also describes method IDs corresponding to the above-mentioned various method names. At the same time, the metaclass method 311 is a sequence schema for instructing the usage order of various methods used in the class, and a message transmission method that the class may need when communicating with others. The respective IDs of are automatically described in the class schema 312.

Corresponding to the generation of the class schema 312, each method ID has its own method 313, 314.
... is pointed, and a class is generated. In addition, regarding the generated class, it is possible to freely delete, replace, or add the method to be used. Further, the metaclass method 311 may be considered to be activated from the side of the class to be generated.

Further, the class schema is invoked from the above-mentioned class name (name of the class with which the self is related) described in the instance schema 316, and the instance class used in various methods used by the class. Data is sequentially input and described in the instance schema 316. It should be noted that this operation may be considered to be performed by the operator by prompting the operator to input each instance data from the class side. Among the instance data, the data that has not been registered as the pop-up data 320 up to that point is the pop-up data 320.
It is automatically registered on.

The data on the instance schema 316 is linked with the method ID on the class schema 312. Needless to say, the instance data on the instance schema 316 is deleted, exchanged, or added as needed. Also, if the method used by the class changes, it will change accordingly.

With the above configuration, it is possible to appropriately use the methods in combination while generating a desired class, changing the method used in the class, and changing the instance data.

[0044]

EXAMPLE A real world (for example, a user's request) is, as modeled in FIG. 17, an inclusion giving specific information for expressing the real world and an extension for simply expressing the real world. Can be associated and modeled. In exchanging information, for example, in exchanging information about a certain real world, it is sufficient to give an extension of the real world if the comprehensions of the real world are understood by each other. . In other words, it is not necessary to notify the other party of specific information, but it is sufficient to notify the other party of the real world name.

FIG. 2 is an explanatory diagram for explaining the static world and the dynamic world. For the reasons described above, the comprehension generally conceals information as shown in FIG. 2, and corresponds to the “world of information concealment”. On the other hand, the real world is a “static world” that gives the mechanism of the real world and the causal relations within the mechanism, and represents the temporal movement of the real world, and is also a parallel system for multiple sessions. It can be modeled with a "dynamic world" that indicates whether processing is allowed or not. The "static world" and the "dynamic world" are associated with the "information hiding world" by extension, as shown in FIG.

Further, the comprehension is a world of information hiding and contains data that gives meaning to the extension. This real meaning is used to simulate the real world.
That is the static model corresponding to the "static world",
It is a dynamic model corresponding to the "dynamic world."

FIG. 3 is an explanatory diagram for explaining the relationship among the static model, the dynamic model, and the functional model. The static model shown in FIG. 3 is a model corresponding to the static world shown in FIG.
Similarly, the dynamic model is a model corresponding to the dynamic world.
In addition, the world of information hiding shown in FIG. 2 is associated with the functional model.

A static model is formed by specifying the mechanism of the system and designing the relations (templates) such as "is-a" and "part-of" described above. Then, a functional design is obtained, and a class 302 (or a class obtained by further compounding a plurality of classes-combined class) shown in FIG. 1 is designed in a corresponding form.

In the dynamic model, a specific processing target unit (instance) is formed by allocating the instance data in the above-mentioned class 302, and the temporal order relationship between the processing target units is designed. Formed by. Then, a constraint due to a causal relationship is given between the static model and the dynamic model.

FIG. 4 is an explanatory diagram showing the relationship between the diagram shown in FIG. 1 and the diagram shown in FIG. 3 in association with each other. Reference numeral 3 shown in FIG.
12 to 316 correspond to FIG. The “static world” shown in FIG. 4 corresponds to the “static model” shown in FIG.
The "dynamic world" corresponds to the "dynamic model" shown in FIG.

A method for performing each desired data processing is formed, a plurality of methods are combined to form a class, and a plurality of classes are combined as necessary to form a composite class. Or has been. These are placed in the world of information hiding shown in FIG.

In forming a class, as described with reference to FIG. 1, a class name is specified in the class schema 312 and used in the class corresponding to the method setting (change). The method ID for the method that can be imported is described. At the same time, the method ID and each method 313, 314, ... Are linked. Also, the sequence in which each method is executed is set.

An instance schema 316 is formed corresponding to a specific process. That is, the class name of the class that uses the instance is described in the instance schema, and individual instance data is described.

Corresponding to the formation of the above class and the formation of the instance schema, the static world has classes and methods chained under a certain state table, and variables and variables associated with each method. It is formed so that there are constants and. If necessary, the above-mentioned "is-
It is related to another class under the relationship of "a" or the relationship of "part-of." Furthermore, a constraint group that gives a causal relationship is set.

In the dynamic world, when a session is created, the processing order is specified, and when parallel operations are performed, the timing for that purpose is designated. FIG. 5 is an explanatory diagram illustrating a state in which a class is generated from a metaclass. Reference numerals 300, 310, 3 shown in FIG.
11, 312, 313, 314, 315 and 316 are shown in FIG.
It corresponds to the one shown in. Reference numeral 317 is a message transmission method, 318 is a gasoline cost calculation method shown as an example, and 319 is an object management unit 220.
It represents a sequence table provided inside.
Reference numeral 220 represents an object management unit.

As described with reference to FIG. 1, the metaclass method 311 is used to set the class name of the class to be created and to specify the method used in the class. At the same time, message transmission method 3 for the class to communicate with others
17 and the like are automatically set, and the order relation of each method used in the class is set.

Correspondingly, the class schema 312
Method ID for each imported method above
The message transmission method ID and the sequence schema are described. Then, each ID and each method are linked.

A specific processing program is formed by specifying an instance using the created class. In the case shown in the figure, an instance schema 316 that includes a specific instance is prepared for the class “car”.

When, for example, a message using a predetermined instance schema is given to the object management unit 220, the object management unit 220 activates the instance (takes in the instance schema) and is described in the instance schema. The illustrated class schema 312 is linked from the existing class name, and the sequence schema in the class schema 312 is taken into the sequence table 319. After this processing, the object management unit 220 examines the contents of the sequence table 319, sequentially uses the required method, and uses the contents of the instance schema 316 to process the instance corresponding to the message. .

FIG. 6 is an explanatory diagram for explaining the state of creating an instance from a class. The reference numerals shown in FIG. 6 correspond to those in FIG. Class 3 as described with reference to FIG.
When the method to be incorporated into the class is specified corresponding to 02, the class schema 312 is created in the internal schema 310, and the methods 313, 314, ...
・ Is linked.

In short, the class created in this way, for example, the class related to "car", is a data storage area that is still empty in which rewritable instance data can be set, and various processing related to cars. It can be thought of as consisting of a group of methods for performing. Then, by setting specific instance data in the data storage area of the class created in this way, the instance (specific processing program in which the instance data is used) is created. The specific processing program is the illustrated instance.

In creating an instance, the instance data used in each method is set on the instance schema 316. Then, the content of the set instance schema is linked with the method ID on the class schema 312. This causes the method in the associated class to be executed using the contents of the instance schema 316. A specific processing program (instance) can be executed. The execution is performed by the object management unit 220.
But the instance schema 316 and each method 31
, 314 ... Are activated.

In the case of the present invention, as described above, the metaclass
Using the method 311, the class name of the class to be created is input, various methods to be loaded into the class are mutably loaded, and the class is created in a desired form as appropriate. That is, a desired class is created by appropriately combining the methods. The class is
In the case of the processing program example, it may be considered that the instance data is a processing program in which the instance data is still described in the form of variables.

In the processing program in the state where the class, that is, the instance data is still described in the form of a variable, the one completed by designating the specific instance data corresponding to the variable is specified. It is a processing program for performing the processing of. The processing program in which the variable is set to a constant is the above instance. By setting the instance data to be rewritable in the above-mentioned instance schema 316, a desired instance is created as appropriate.

FIG. 7 is a diagram for explaining a part of the operation in the dynamic object processing section. Various information related to the internal schema 310 described above is stored in the component attribute file 205 as the object component 206 shown in FIG.
Held in. The dynamic object processing unit shown in FIG. 7 performs processing using the object component.
Needless to say, in the case of the present invention, as described above, it is possible to appropriately combine the object parts 206 or the object parts 206 in a composite form.

Reference numeral 212 shown in FIG. 7 denotes a dynamic object processing unit, which is a temporary operation mode 216 for performing a simulation, an instant operation mode 217 for performing a test, and a data processing or communication processing with another terminal. It has a production operation mode 218 for performing.

Reference numeral 205 is the component attribute file shown in FIG. 19, and reference numeral 205 'is the component attribute file 20.
The execution process data 214 is stored so that the actual operation can be executed at a high speed by performing a compile process on all or part of the contents of item 5. In the case of an object program for processing execution, the execution processing data 214 is generally a series of processing units consisting of several tens to several hundreds of steps, which are so-called serially combined.

Reference numeral 213 is the above-mentioned object, which is generally in the form of the above-mentioned atomic object, the above-mentioned capsule object state, the above-mentioned event object state, the above-mentioned object state. Corresponding to each of the system object states. It can be considered that the object 213 is stored in the form of the object component 206 as specified by the object command, as described with reference to FIG.

Reference numeral 215 represents a direct object processing expansion processing, and the individual objects 2
13 is expanded, or a plurality of objects are expanded together to obtain the execution processing data 214.

As described above with reference to FIG. 13, the object is generally grouped in the form of a composite object into the processing target units, and becomes a unit that exhibits the behavior for executing the processing having one purpose. Then, as shown in FIG. 19, they are in the form of the object component 206 specified by the object command 201, and the component attribute file 20
Stored in 5.

In the case of generating a new processing function, a new object is generated or an existing object is purposely combined to perform the new processing function so that the new processing function can be performed. An object to be created is prepared as one of the object parts 206.

Regarding the generated object,
A process is performed such as performing a simulation as to whether or not the device actually functions correctly, or performing a tentative operation when the simulation is completed. This processing is the temporary operation mode 216 shown in FIG. 7, and the dynamic object processing unit 212 uses the contents of the component attribute file 205 to simulate the corresponding processing operation.

Regarding the object 213 or the group of objects that have normally operated in the temporary operation mode 216, the processing speed is slow as it is because it requires a lot of communication with the object management unit (see FIG. 8) in actual operation. To the execution processing data (EXE data) 214 (compiled into one EX
E data). The expansion processing is performed in the illustrated direct object processing expansion processing 215 and stored in the component attribute file 205 ′.

Dynamic Object Processing Unit 212
In the case of using the contents of the component attribute file 205, when it becomes necessary to temporarily perform a proxy process or a test process for a predetermined process, the above direct object process expansion is performed. Process 2
15 may be activated to generate execution processing data 214, and the processing may be performed. Such a processing mode is shown in FIG.
Is shown as instant operating mode 217.

The production operation mode 218 shown in FIG.
This is a mode in which the actual processing operation is performed using the illustrated execution processing data 214. It should be noted that the meta data in the component attribute file 205 describes the semantic data regarding the property of the object, and the upper object (the object indicated by “is-a”) as viewed from its own object. Relations and lower-level objects (“part-
It may be considered that there is a description that indicates the connection relation for the object group indicated by “of”.

FIG. 8 shows the structure of the terminal station. Reference numerals 202, 203, 204, 205, 205 ′, 20 in the figure
6, 212 and 214 correspond to FIG. 19 and FIG. 7. Further, reference numeral 101 represents a terminal station which performs processing execution using the execution processing data 214 or communicates with another terminal station via a line. Reference numeral 103 is a LAN
It also represents a line such as a switched line. Terminal 101
A communication / reception processing unit indicated by reference numeral 219, an object management unit indicated by reference numeral 220, a display indicated by reference numeral 221 and a hyper-language processing unit indicated by reference numeral 222 are further present therein.

The processing of the illustrated directory processing unit 204 is as described with reference to FIG. 19, and the processing of the illustrated dynamic object processing unit 212 is also as described with reference to FIG. 7.

The (temporary operation support) shown in FIG. 8 is a support function corresponding to the operation up to the temporary operation mode 216 shown in FIG. The illustrated hyper-language processing unit 222
Has a "part display / selection" function, which searches the display object 221 for available object parts and outputs them. If there is no suitable object, a new object part is designated by using the "part designation" function.
Class object parts can be created by the "Attribute setting" function, and instance object parts can be created by the "Schema" setting function.

The "component display" function using the display 221 includes (i) a table of contents for outputting the name and comment of the metadata of the object component, and (ii) a schema and attributes indicating the contents of the object component. Display of,
(Iii) There are indications of class attributes and instance constants.

In addition, the "component combination" function by the hyper language processing unit 222, that is, in order to obtain a larger composite object component by combining object components, an attribute addition / modification / deletion function is prepared for class creation. The function to add / change / delete the schema is provided for creating instance constants.

In the "user screen creation" function by the hyper language processing unit 222, when creating and displaying the screen,
Put screen data in the buffer of "Creation and display" class and create an instance. Therefore, the "user screen creation" function is equivalent to instantiating the screen class.

In the "provisional operation" function of the hyper language processing unit 222, when a message is received by an instance, it is linked with the method indicated by the class to temporarily realize a capsule on the primary memory (see FIG. 16C). Perform the behavior of the capsule.

Furthermore, the function of "part change" in the hyper language processing section 222 is to change / add / change attributes and schemas.
This is a function that changes the object component by deleting it. Also, the "part registration" function is used for the part attribute file 205.
This is a function of registering the object component in association with the object command (which is the name of the object component).

The "expansion (compilation)" shown in FIG. 8 is the direct object processing expansion processing 215 shown in FIG.
Is represented. In the expansion processing, the execution processing data 214 is expanded as large as possible according to the size of the primary memory of the data processing device.

The object management unit 220 controls the hyper language processing unit 222 shown in FIG. 8 to hold the object component 206 in the component attribute file 205 as described above, and controls the dynamic object processing unit 212 to temporarily store it. Operation mode 216 or instant operation mode 21
7 and the actual operation mode 218 are performed. Also,
In response to the message reception via the line 103, the instance is activated in the temporary operation mode, the data processor is operated by temporarily encapsulating on the primary memory, and the result of the processing is transmitted as a message. . Of course,
If there is already expanded data in the execution processing data 214,
Execute it and send a message to the partner terminal.

In the processing in the own terminal station 101, if the desired object component does not exist in the own terminal station 101, has no attribute, or has no schema, the other end station receives the information from the other terminal station via the line 103. After being transferred,
Learning is carried out at the place where it is taken into the own terminal station 101.

FIG. 9 is an explanatory diagram for explaining the relationship between a plurality of classes. FIG. 9A shows a case where a certain class X and another class Y have an "is-a" relationship. For example, if class X is a program related to "cars",
This shows a case where the class Y has a relationship such that it is a program related to "passenger car".

In the case of FIG. 9A, it is shown that the methods a, b, and c are incorporated for the class X and the methods d and e are incorporated for the class Y. In such a case, if it is instructed to execute the class Y, in executing the class Y, the methods a, b, and c are inherited from the class X, and the methods a, b, and Processing based on c, d, and e is executed.

FIG. 9B shows a class X and another class α.
And β have a “part-of” relationship. For example, the case where the class X is a program relating to “car” and the classes α and β are programs such as “body”, “engine”, “wheel” ... ing.

In the case of FIG. 9B, the methods a, b, and c are included in the class X, the methods p and q are included in the class α, and the methods r and s are included in the class β. Shown as being present. In such a case, if it is instructed to execute the class X, in executing the class X, the processing based on the methods a, b, c, p, q, r, and s is executed. To be

As an example of the template, the above "is
Although only "-a" and "part-of" are shown, the present invention is not limited to this, and Fig. 10 is a diagram for explaining the configuration of the object management unit.
5, which is shown in FIGS. 5, 6 and 8, executes processing using various information existing in the component attribute file 205.

Since the object management unit 220 executes the process corresponding to the message as shown in FIGS. 5 and 6, it is possible to execute a plurality of messages in parallel. It should be. From this, as shown in FIG. 10, an object management unit class 330 (hereinafter may be referred to as an obv class) is prepared, and a plurality of obv instances 331 and 332 are provided in response to receiving a message. , ... 333 can be generated. Then, in response to the reception of each message, one observer instance is allocated each time, a plurality of observer instances are processed in parallel, and a plurality of messages are processed in parallel. Of course, if messages are concentrated in a short period of time, individual observer instances such as 3
A waiting queue corresponding to 31 may be formed.

FIG. 11 shows an operation flow in the object management section. (S1): The instance schema 316 is read in correspondence with the message, corresponding to the instance required to execute the message. (S2): The class schema 312 is read by the class name described in the instance schema 316. (S3): Based on the contents of the class schema 312, the method specified by the class schema is retrieved.

In this way, the required method is extracted, but in the class schema 312, "is-
If there are upper or lower classes in the relationship of "a" or "part-of", those classes are obtained.

The method for the related class is inherited as described with reference to FIGS. 9A and 9B. (S31): A class having a relation of "is-a" or "part-of" is obtained. (S32): Extract all related methods. (S4): The methods incorporated in the class are sequentially activated in accordance with the sequence data described in the class schema 312. (S5): When the above process corresponding to one message is completed, the process for the next message is executed.

FIG. 12 is an explanatory diagram for explaining the clothes (rolls) of the method. As described with reference to FIG. 2, the world of procedures corresponding to the inclusion is associated with the world of objects through the extension. Further, as described with reference to FIG. 16, the method itself also constitutes one object. The method is also present in the procedural world.

However, when a method is handled alone,
If it exists only in the method itself, when is the method born or disappeared (live / dead), whether it should be made resident (open / closed), and other information Where to receive the input data (Input) and where to output the data (Output)
It is often unclear.

For this reason, in the present invention, a verb (V in the figure) and a complement (C in the figure) for instructing the operation of the method are described together with the method itself (M in the figure) to form one object. To be done. The verb V and complement C
Therefore, in the present invention, it is called method clothing.

FIG. 12A shows that the method is located in the procedure world as an object.
Further, in FIG. 12B, the clothing of the above method is described in the method incorporated in a certain class,
This means that data output and data input are performed independently.

The clothing of an object provides a life cycle function for a method to act as an object independently. Make the object autonomous by having the life cycle function. That is, the garment allows the method selected by the operator via the extension to acquire the condition for allowing the operator to operate. In short, it is for preparing the data acquisition means for the selected method itself to instruct the operator to acquire the necessary data.

As the clothing of the object, "life or death", "open / closed", "Input", shown in FIG.
In addition to "Output", other methods include (i) "Send message" to notify the end of an object when it operates, and (ii) the request function including the clothing of the object. It has "sequence control" etc. that gives the processing order of.

[0102]

As described above, according to the present invention, a metaclass in which a class is an instance can be prepared, and a class desired by an operator can be freely created by a metaclass method (that is, , A class can be created by importing multiple methods in a desired order under a certain class name), and an instance desired by an operator can be freely created by using the created class. (That is, by setting the desired instance data in the empty data storage area in the class to be rewritable,
You can create an instance).

[Brief description of drawings]

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

FIG. 2 is an explanatory diagram illustrating a static world and a dynamic world.

FIG. 3 is an explanatory diagram illustrating a relationship among a static model, a dynamic model, and a functional model.

FIG. 4 is an explanatory diagram showing the relationship between the diagram shown in FIG. 1 and the diagram shown in FIG.

FIG. 5 is an explanatory diagram illustrating a state in which a class is generated from a metaclass.

FIG. 6 is an explanatory diagram illustrating a state of generating an instance from a class.

FIG. 7 is a diagram illustrating a part of the operation in the dynamic object processing unit.

FIG. 8 is a diagram showing a configuration of a terminal station.

FIG. 9 is an explanatory diagram illustrating a relationship between a plurality of classes.

FIG. 10 is a diagram illustrating a configuration of an object management unit.

FIG. 11 shows an operation flow in the object management unit.

FIG. 12 is an explanatory diagram illustrating clothing (rolls) of a method.

FIG. 13 is a diagram illustrating an advantage of encapsulating an object.

FIG. 14 is an explanatory diagram modeling a company department.

FIG. 15 is an explanatory diagram showing the model in an abstracted manner.

FIG. 16 is a diagram illustrating a capsule.

FIG. 17 is a diagram for explaining an object by modeling it.

FIG. 18 is a diagram illustrating a function of a modeled object.

FIG. 19 shows a processing mode for handling an object.

[Explanation of symbols]

 101 Terminal Station 103 LAN or Switched Line 205 Component Attribute File 206 Object Component 212 Dynamic Object Processing Unit 220 Object Management Unit 301 Metaclass 302 Class 303 Instance 310 Internal Schema 311 Metaclass Method 312 Class Schema 313 Method 316 Instance Schema 330 Object Management Department Class 331 Observer Instance

 ─────────────────────────────────────────────────── ─── Continuation of the front page (72) Inventor Masahiko Murakawa 100-1 Sakado, Takatsu-ku, Kawasaki-shi, Kanagawa Fujitsu Network Engineering Co., Ltd. (72) Inventor Masanobu Toyota 100-1, Sakado, Takatsu-ku, Kawasaki-shi, Kanagawa (72) Inventor Takeshi Adachi Fujitsu Network Engineering Co., Ltd. 100-1 Sakado, Takatsu-ku, Kawasaki-shi, Kanagawa

Claims (9)

[Claims] 1. An object-oriented data processing device, which names a single processing unit and / or a composite processing unit obtained by combining a single processing unit as an object, combines the objects, and executes a desired process, The object is configured to be stored in the parts attribute file (205) as an object part (206) with entity data forming the object and meta data describing the property of the object, and object management The part (220) is configured to communicate with the object part (206) on the part attribute file (205) and execute the desired processing.
Regarding the internal schema (310) that forms 6), at least one method (313 or 31) that can be mutably incorporated in the self-class in the data concerned.
4) includes a class schema (312) describing a method ID that points to 4), and an instance schema (316) that modifies the instance data used by the imported method,
The schema (312) includes at least a sequence schema indicating the order of use of the methods incorporated in the self class, and the class schema (31
2) The method ID described in 2) and the content described in the instance schema 316 are configured to be linked, and the method () that can be changed in the class schema (312) is modifiable. 313
Object-oriented data processing device, characterized in that it has a metaclass method (311) for mutably capturing (eg,). 2. When creating the class, the metaclass method (311) is activated to instruct the input of the class name of itself and the method (313 etc.) to be taken into the own class. Method ID
Is prompted to enter, and the entered method ID
The object-oriented data processing device according to claim 1, characterized in that said method and said fetched method (313, etc.) are linked. 3. The metaclass method (311)
3. The object-oriented data processing according to claim 2, characterized in that a sequence schema representing the order of use of the methods fetched in the class is automatically generated and described in the class schema (312). apparatus. 4. The metaclass method (311)
Associates at least the message sending function of the created class with the object management unit (220) with the class, and creates the class schema (312).
3. The object-oriented data processing device according to claim 2, wherein the message transmission ID is described therein. 5. In creating the instance schema, one of the classes is activated, and at least an instruction to input a class name of a class related to the self instance schema is specified and the class is specified. Make sure to input data matching the specified data item name, and make a link between the content described in the instance schema and the method ID described in the class schema (312). The object-oriented data processing device according to claim 1, wherein 6. The object management unit (220) comprises:
The object management unit class (330) has its own processing function, and the object management unit (22)
1 corresponding to the received message received in 0)
2. The object-oriented data processing device according to claim 1, wherein one or a plurality of object management instance schemas (331, 332, etc.) are generated by inheriting the processing function from the object management unit class (330). 7. One of the generated object management instance schemas (331, etc.) corresponds to the received message in parallel with the processing of another object management instance schema (332, etc.). Read the above instance schema (316),
7. The class schema (312), which is a used class, is read from the instance schema (316) and the methods are sequentially activated based on the contents of the class schema (312). The described object-oriented data processing device. 8. In the above-mentioned class, at least another class connected under the relation of "is-a" and a connection related to its own class under the relation of "part-of". 2. The object-oriented data processing device according to claim 1, wherein the class is described in a rewritable manner, and in executing a process in the own class, another related class can be called. . 9. The method (313, etc.) describes the clothing (also) of the object for enabling the method to operate autonomously, and at least the self clothing by the clothing of the object. 2. The object-oriented data processing device according to claim 1, further comprising an input processing function and an output processing function for communicating with an operator regarding data required for the method.