JPH07114461A - Object-oriented data processing system - Google Patents

Abstract

PURPOSE:To generate automatically a program required for system build-up efficiently by obtaining an object corresponding to a specification language from among objects registered already when the specification language is received and generating an object required for system buildup through the operation of the object. CONSTITUTION:A questioning means 10 executes input setting processing of a specification language as to the system to be built up, and a 1st specification means 11 specifies an identification name of an object indicated by the specification language to be set. A 2nd specification means 12 specifies a signature of an object indicated by an identification name as a tentative signature for system buildup and the 2nd specification means 13 specifies a signature similar to the tentative signature. A generating means 14 sets a processing object among specified signatures and selects gene information of the signature and a generating means 15 links objects while matching the characteristics to generate an object required for system buildup.

Description

Detailed Description of the Invention

[0001]

BACKGROUND OF THE INVENTION 1. Field of the Invention The present invention grasps the real world as an object model, associates the real world with an extensional noun and a comprehension, and places the comprehension in an information hidden area.
The so-called iD information for identifying the comprehension is configured by being associated with an extensional noun, and the real world is causally related to the static world and the dynamic world forming the world of the object by using the extensional noun. The static world is represented as a static model, and a system mechanism using a class and / or a composite class is given as a static model. A session corresponding to the movement of the dynamic model is given by using an instance of a composite class, and a causal relationship generated from the static model and the dynamic model is given as information in the static model. Occasionally, an object that realizes the automatic generation of programs (objects) necessary for building a system and efficiently realizes the automatic generation. On-oriented data processing system.

[0002]

2. Description of the Related Art Conventionally, when constructing a system, a system designer listens to a user to design a system (top-down thinking), and, on the other hand, a component design (bottom design) to determine whether it is feasible. Up thinking), and by repeating the work of both parties, the system will be designed while closing the gap between top-down and bottom-up.

When the system designer collects the system specifications, the programmer creates a program necessary for constructing the system based on the specifications.

That is, in the conventional system development, a method is adopted in which a system designer compiles user's work contents and requirements as a specification, and a programmer creates a program based on the specification.

However, in such a conventional technique,
The system development is carried out manually, so to speak, there is a problem that the system development takes time.
And, especially, the system designer encounters various demand offensives from the user, and on the other hand, it encounters the difficulty of the program to realize this and has a problem of having a great difficulty.

[0006] As described above, the reason why the user's request appearing in a top-down manner cannot be easily reflected in the program is as follows.
In the current software structure theory, "file structure",
The design of “common resources”, “task level”, etc. becomes complicated, and it is difficult to easily model or change the real world.

That is, in the case of designing a system with the current procedural program, the following five problems in software creation are listed as the major causes of impeding the efficiency. (1) Complexity of trigger condition and operation level setting In the current procedural program, while constantly watching the movement of the entire system, it is possible to determine all internal states of which program is to be activated in what kind of state. It is necessary to compile them as a state diagram or state transition diagram and carefully set commonly used flags and registers. With such a design, when the user requests a modification, the design is almost always rebuilt. (2) Complexity of file design The goodness and badness of the file structure are deeply related to the number of times of access to the file, which greatly affects the response. Also, because the file is used only in a specific program because it is closely linked to the processing program, and it is very difficult to change it once created, it requires careful design by a file design expert. . The file designer must understand all the types and characteristics of the input data used by the program, know how to process them, and how to output them. become. (3) Complexity of common resource design How to use common resources such as flags, buffers, files, etc.
The performance of the system is greatly affected. It is more serious than the file design described above, and it is related to the life and death of the system, and it is necessary to design it while paying close attention to the start and end conditions and the state of each task. (4) Difficulty in securing reliability Common resources are referenced and updated from time to time by many programs, and if there is a defect such as conditional missing, the impact will be widespread, and in some cases, This will cause the system to go down. (5) Complexity of screen data creation The most difficult part of system design is screen design. Input / output item settings and various data (code system,
(Dot system, vector system, sound system, still image, moving image, etc.), and there are many considerations from the viewpoint of operability and legibility such as arrangement on the screen, size, color arrangement, blinking process, etc. The number of screens can easily reach hundreds, which is a very troublesome task.

[0008]

Against this background, the present inventors have proposed a new object-oriented data processing system. next,
The object-oriented data processing system proposed by the present inventors will be described.

In order to simplify the system design, it is important to easily and faithfully replace the real world with a model. Therefore, the present inventors have paid attention to the fact that the human words that we use are "extended interpretations that give conceptual recognition," and O-id (extended name or (Sometimes referred to as object command) is introduced, and an object thinking design method (we dare call it object thinking rather than object oriented) that designs objects with this extensional name is newly introduced. Figured out This makes it possible to construct an object model with the same feeling as we normally grasp phenomena in the real world, and to create a world that can be called a virtual human world that brings the human world into the object world. .

In this object thinking design method, the object in the real world is divided into the world of an extensional name and the world of information-hidden comprehension. The world of this extensional name is called the object world. The object world is roughly classified into three categories of "static model world", "dynamic model world", and "causal relationship model world" in terms of schema theory.

The static model in the object world indicates a relationship that exists at the same time even if the modeling target time is stopped. In addition, the dynamic model in the object world indicates a relationship that exists by moving the time to be modeled. In addition, the causal relationship model in the object world indicates a temporal relationship in a dynamic model developed from a static model.
The object world (virtual human world) that constitutes the static model and the dynamic model functions according to various laws and rules. It can be, for example, a natural law or a social rule. The function defined in the dynamic model must operate according to this law and rule.
Usually, there are ones defined by a static model (things unrelated to the time axis) and ones defined by a dynamic model (laws or rules related to the time axis). The latter is
In terms of implementation, it can be viewed as a static model with time as a parameter. A model that defines a time-axis relationship in such a dynamic model is called a causal relationship model.

As described above, the static world, the dynamic world, and the causal world formed by the extensional nominatives are so-called "composite worlds by nominatives" in which the nominatives are related by pointers or messages. Has become.

[0013] Generally, human thought is used by giving more properties or names to these "complexes". Once defined, the nomenclature can further compose the object world.
At that time, the constituents and definitions of the complex do not need to be deeply recognized in the object world, that is, the virtual human world, and are performed by extensional interpretation.

On the other hand, the information hiding model in the world of information hiding is the definition resulting from the static world, the dynamic world, the causal world in the world of the above-mentioned extensional name, or the atomic object (basic of the object). It is a model of the entity and the entire contents at the level). The only interface between this information hiding model and the object world (virtual human world) is taken as an extensional name.

The object-oriented data processing system newly proposed by the present inventors based on such a technical idea is as follows.
Since it is based on a completely different way of thinking from conventional software technology, programs (objects) necessary for constructing a system by adding new functions.
It is possible to realize the automatic generation of, and to realize the automatic generation efficiently.

The present invention has been made in view of the above circumstances, grasps the real world as an object model, associates the real world with an extensional name and a comprehension, and conceals the comprehension of information. ID information that identifies the comprehension is associated with an extensional noun, and the real world is moved to a static world that constitutes the world of the object by using the extensional noun. The static world and the causal world, the static world is given a system mechanism using a class and / or a composite class, and the dynamic world is a dynamic model. As a result, a session corresponding to the movement of the dynamic model is given by using an instance of the class and / or the composite class, and the causal relationship generated from the static model and the dynamic model is displayed. New object-oriented data that realizes automatic generation of programs (objects) required to build a system at the time of adopting a configuration that is given as information in a static model, and that also realizes the automatic generation efficiently. The purpose is to provide a processing system.

[0017]

In the present invention, a single processing unit and / or a composite processing unit in which a single processing unit is combined is named an object, the objects are combined, and a desired processing is executed. In the object-oriented data processing system,
It is regarded as a model, and the real world is associated with an extensional noun and a comprehension, the comprehension is placed in an area where information is hidden, and so-called iD information that identifies the comprehension is associated with the extensional noun Then, using the extensional nomenclature, the real world is represented by a static world, a dynamic world, and a causal world that compose the world of the object, and the static world is a static model. As a system mechanism using a class and / or a composite class, and for the dynamic world, an instance of the class and / or the composite class is used as a dynamic model to correspond to the movement of the dynamic model. A session is given, and a causal relationship generated from the static model and the dynamic model is given as information in the static model.

In adopting this configuration, the present invention realizes automatic generation of a program (object) necessary for constructing a system according to the principle configuration as shown in FIG. Will be realized.

The object-oriented data processing system 1 whose principle configuration is shown in FIG. 1A is an inquiry means 10 for executing an input setting process of one or more spec words for a system to be constructed, and an inquiry means. First identification means 11 for identifying the identification name of the object indicated by the specification word set by 10, and data held by the object indicated by the identification name identified by the first identification means 11,
The second specifying means 12 for specifying the signature for displaying the meaning of the object, and the second specifying means by evaluating the similarity between the signature specified by the second specifying means 12 and the signature of another object. Third specifying means 13 for specifying a signature showing similarity to the 12 specified signatures, and third specifying means 13
Set the processing target from among the signatures specified by
Necessary for system construction by combining the creating means 14 that creates a new object by selecting the signature element of the signature to be processed and moving it as necessary, and the object created by the creating means 14 while matching the compatibility. And a generation unit 15 that generates an object that becomes

The object-oriented data processing system 1 whose principle configuration is shown in FIG. 1 (b) interacts with the display screen when a plurality of objects whose sequence structure is specified is specified, and the compatibility of the objects When there is another object that has a causal relationship with the object, the compatibility execution means 20 that executes a combining process between the two objects while executing the matching.
And a management unit 21 that manages sequence information between objects and causal relationship information obtained by the execution of the compatibility execution unit 20 as compatibility result information while distinguishing between compatibility match / mismatch.

The object-oriented data processing system 1 whose principle configuration is shown in FIG. 1 (c) includes rule management means 30 for managing compatibility rules established between objects,
When a plurality of objects whose sequence structures are not specified are designated, the structured execution means 31 for giving the sequence structure to the objects according to the combination of the objects and the management data of the rule management means 30 are used for the structured execution. When the compatibility of the objects structured in sequence by the means 31 is evaluated and it is determined that the objects function as compatible objects, the compatibility is given to the objects to generate the objects as valid objects. And generating means 32.

The object-oriented data processing system 1 whose principle configuration is shown in FIG. 1D, when a plurality of objects to be combined are designated, displays the objects in the logo format on the display screen and By interacting with the display control means 40 that displays the attribute information of the object on the display screen in association with the logo display and the display screen, the matching process between the objects of the logo display and the value setting of the attribute information. By executing the processing and the processing, the combining execution means 41 for executing the combining processing between the objects designated as the combining target.
With.

[0023]

The present invention, whose principle configuration is shown in FIG. 1 (a), is a program (object) required for system construction.
For realizing the automatic generation of
By interacting with the user, an input setting process of one or more spec words for the system to be constructed is executed, and the setting of the spec words causes the first specifying unit 11 to set the specs. Identify the identification name of the object that the word points to.

When the identification name of the object is specified,
The second identifying means 12 identifies the signature of the object indicated by the identification name (metadata that describes the meaning of the object) as a temporary signature for system construction, and identifies the temporary signature. In response, the third specifying unit 13 specifies a signature similar to the temporary signature by evaluating the similarity between the temporary signature and the signature of another object such as a session.

When a signature similar to the provisional signature is specified, the creating means 14 interacts with the user to set a processing target from the specified signatures, and the signature of the signature set as the processing target is set. A new object is created by selecting the gene information (which describes the connection relationship between the objects) that it has and moving it as necessary, and upon receipt of this creation result, the creating means 15
Interacts with the user to combine the created objects with compatibility and generate the objects required for system construction.

As described above, in the present invention whose principle configuration is shown in FIG. 1A, when the user inputs a spec word necessary for constructing the system, the spec word is directly input from the registered objects. Alternatively, it indirectly obtains related objects and operates the objects to generate the objects required for system construction. Words work effectively in the domain of the system. Because it has the property of
Preferably, the spec word is defined for each domain of the system, and the processing is executed corresponding to the domain of the system to be constructed.

According to this configuration, the user can generate the program necessary for constructing the system simply by inputting the spec word which is an extensional name into the object-oriented data processing system 1.

The present invention whose principle configuration is shown in FIG. 1 (b) realizes the efficiency of the automatic generation of the program realized by the invention of FIG. 1 (a). When a plurality of objects for which the sequence structure is specified are designated, it is determined whether or not the sequence structure of the object is registered in the management means 21, and when it is determined that the sequence structure is not registered, the dialogue with the display screen is performed. By doing so, the compatibility of the object is executed, and if there is another object that has a causal relationship with that object, the combining process between the two objects is executed and the compatibility result information of the execution result is obtained. Register in the management means 21.

On the other hand, when it is determined that the sequence structure of the object is registered in the management means 21 as compatibility match, and there is another object having a causal relationship with the object, both objects are The inter-joining process is executed, and the compatibility result information of the execution result is registered in the management unit 21.

As described above, according to the present invention whose principle configuration is shown in FIG. 1B, when a plurality of objects whose sequence structures are defined is designated, it is efficient while utilizing the result of past compatibility matching. The processing is performed so that the compatibility of the object is executed.

The present invention whose principle configuration is shown in FIG. 1 (c) realizes the efficiency of automatic generation of a program realized by the invention of FIG. 1 (a). , When a plurality of objects whose sequence structure is not specified are specified, the sequence structure is given to the object according to the combination of the objects. When sequence structured in this way,
The generation unit 32 uses the management data of the rule management unit 30 to evaluate the compatibility of the sequence-structured objects, and when determining that the objects function as compatible objects, the objects are evaluated. Creates the object as a valid object by giving compatibility to.

As described above, in the present invention whose principle configuration is shown in FIG. 1C, when a plurality of objects whose sequence structure is not specified are designated, the objects are automatically combined to generate a new object. It is processed as it is done.

The present invention whose principle configuration is shown in FIG. 1 (d) realizes the efficiency of automatic generation of a program realized by the invention of FIG. 1 (a). When multiple objects to be combined are specified, the objects are displayed in the logo format on the display screen, and the attribute information of the objects is displayed on the display screen in association with the logo display. Receiving the display result, the combining execution means 4
1 interacts with the display screen to execute compatibility matching processing between logo-displayed objects and attribute information value setting processing.

As described above, according to the present invention whose principle configuration is shown in FIG. 1D, the process of visualizing the connection process between objects is performed.

[0035]

EXAMPLES The present invention will be described in detail below with reference to examples. FIG. 2 illustrates the advantages of encapsulating an object as in the case of the present invention. Taking the execution processing data 214 as an example, for example, as shown in FIG. 2A, the execution processing data is given as a series of instructions (or a group of instructions) 250 serialized in the processing order. A group of some of these commands (or command groups) 250 collectively performs a predetermined process, that is, a processing unit 25 that performs a certain behavior.
Make up 1.

Therefore, the execution processing data shown in FIG. 2A can be regarded as serialized processing units 251 that perform a certain behavior as shown in FIG. 2B. The execution process data 214 serialized as shown in FIG. 2B 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. 2C, the individual processing units 251 are integrated under a predetermined method M as necessary. By doing so, it is possible to obtain the data which causes the same operation as the execution processing data 214 shown in FIG.

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.

An example of modeling in the real world, for example, a company department, is shown in FIG. In FIG. 3, for example, a “secretary” belonging to “job type = 1” is included in a frame representing “employee”, and a “leader” belonging to “job type = 2”.
There are “workers” belonging to “work type = 3”.
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 "unit of work". Related to "machine".

The "team" and the "machine" are related to each other under the relationship of "machine / workplace", and the "worker" and the "machine" are related to each other under the relationship 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. , The job type is associated with the object "employee number", the name is associated with the object "code name" and the object "surname", the salary is associated with the object "dollar", and the average salary is associated with the object "dollar". "Number" by the average number of departments associated with
(3) "secretary" is related to the object "number" by the typing speed, (4) "affiliation" is related to the object "name" by name, and the 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. 3, generally, for example, when the circle mark is “behavior” (or method), the square mark is “data”, and the diamond mark is “relation”, the model shown in FIG.
Can be represented as shown in. That is, (1) method a and data I are combined into one larger data
Acts as IV, and (2) methods b and c are related to data II by the relationship α, and one larger data V
(3) methods c and d are related to data III by the relationship β, and one larger data VI
And (4) method e is data by the relation γ.
One larger data VI associated with IV, V and VI
It can be described as acting as an I, forming a larger group that is grouped together, intertwined, and so on.

The circles, squares and diamonds shown in FIG. 4 are 1
It can be treated as an object one by one.
Now consider a collection such as method a and data I shown in FIG.
Considering the encapsulation as shown in FIG. Figure
5 (A) has a hole above the capsule
Indicates that the message can be exchanged.
Temporarily block the upper hole of the capsule shown in FIG.
If so, such as method a and data I shown in FIG.
Corresponds to data IV, which is a gathering. The data is shown in FIG.
It is shown at the left end of (B). The leftmost day in Fig. 5 (B)
Object combined with method M for data D
The data shown in the center of FIG.
And a composite object with a method added on it.
When obtained, the result is as shown in the right end of FIG. This
What was compounded as shown in Fig. 5 (C)
There is. The mode in which compounding is performed is limited to the shape of FIG.
It is not something that can be done. For example, in the leftmost end of FIG.
Data D is called method and data in the object.
When replaced with another object, the left edge of Fig. 5 (C)
It is the second one. In this case,
Dead M₁And data D₁Message passing between and
Is required, which is the third from the left end of FIG.
Method M ₁Is an object. This conclusion
As a result, object A and object are in object C.
B exists, and object A and object B
Even the structure that there is message passing between
It becomes one.

Further, assuming that the method M in the illustrated object B is the object B ₁ and the data D in the object B is the object B ₂ , FIG.
(C) As shown at the rightmost end, object B ₁ and object B ₂ exist in object B, and message passing exists between object B ₁ and object B ₂ .

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. 5, 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 collecting individual processing target units.

As shown in FIG. 4, the individual objects I, II and III are larger objects IV, V and VI, respectively.
Form part of. The objects IV, V and VI also form part of the larger object VII. In other words, objects IV, V, and VI are object VIs, respectively.
From the perspective of I, the relation represented by “is-a” in the object VII and “part-of-part”
of) ”.

When the illustrated objects I, II, and III are considered to be the minimum units, these objects I, II, and III are so-called atomic objects. Then, if they are collected, what is called a capsule object is formed, if they are collected, 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, it may be considered that the non-decomposable simple substance such as 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. 6 is an explanatory diagram for modeling and grasping the object.

Some real-world things, such as photographs, can be identified by the name representing the photograph and the nature of what the photograph is, for example, who photographed what time. it can. And the picture is
(I) A command as a name to identify the photo, and (i
i) The entity of the picture (entity data) consisting of so-called black and white dots of the photograph, 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 understood 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. FIG. 7 is a diagram for explaining the function of the modeled object.
An object can be represented by a command, a link, and entity data, as shown on the left side of FIG.
It can be considered that dot data as shown in the figure is given to the entity data. Then, the above-mentioned capsule object, event object, system
As shown in the right side of FIG. 7, an object is generally given a description for specifying another object X, Y, Z as entity data, and the other object X, Y,
The entity data x, y, z of the other objects X, Y, Z which are related to Z are used.

As illustrated in FIG. 3, the real world is divided into individual "processing target units" or "processing target units" in which individual processing target units are collected and can be treated as one unit to be processed. The corresponding objects are intricately related to each other.

FIG. 8 shows the basic structure of an object-oriented data processing system constructed according to the present invention. Reference numeral 310 in the figure is an internal schema, which generates a class or a composite class corresponding to a processing request given a new purpose, and also generates the generated class or composite class (hereinafter, for simplicity, both Instance may be represented) is generated.

Reference numeral 410 represents a static world, 420 a dynamic world, and 431 a functional model. Ascertaining the real world as an object model and associating the real world with an extensional noun and a comprehension, (i) the comprehension is an existing method 313 as a functional model 431 in a region where information is hidden. And class 302 are stored in the system (newly created methods and classes are also stored), and (ii) extensional names are stored in the system as static world 410 and dynamic world 420. Has been incorporated into.

The static world 410 has a plurality of methods 313.
And the class 302 are grouped as a class corresponding to a new processing request, and the classes are combined to provide a system mechanism for executing the new processing request. In the dynamic world 420, the instances corresponding to the respective classes are combined in the processing order for executing the new processing request,
It provides a dynamic model for running the system as sessions are created.

In the figure, reference numeral 312 is a class schema, and functional portions for generating a class, 313 to 315 are methods, respectively, which are taken in by the class schema 312 as constituent elements of the class corresponding to the new processing request. Method.

Reference numeral 316 is an instance schema, which represents a functional part for generating an instance associated with each of the classes corresponding to the new processing request.

Reference numeral 303 is an instance, 414 is a state table, 415 is a causal constraint group, and 416 is a class variable / constant. The state table 414 is
It may be considered that the system constructed to correspond to the above new processing request describes the hierarchical relations etc. of a plurality of classes taken as constituent elements, and links the used class variables / constants. . The causality constraint group 415 is also written in the state table 414,
It describes causal relationships that are constraints in executing a session in the illustrated dynamic world 420. For example, a causal relationship is described such that the instance a must be executed when executing the instance b, and the causal relationship is checked when executing the session.

At the time of adopting this configuration, when it is instructed to assemble a system corresponding to a new processing request, each class that is a component of the system is generated. In generating each class,
The class schema 312 is provided with the names of methods and classes required to configure the class and pointers that point to the method and class. And
The necessary methods and classes are imported from the functional model 431 to the internal schema 310 side. In response to the generation of the class, the instance schema 316
Create an instance required to execute the class. Then, each generated instance is associated with a class that uses itself.

Each class generated above is the static world 41
Within 0, it is linked to the state table 414 and is a component in the system assembled to meet the above new processing request. The illustrated class 302 'represents the class that is the component. On the other hand, the dynamic world 42
At 0, each instance 303 is combined in time series and a session is assembled in order to execute the system. Then, by executing the session, the system is executed. Alternatively, by assembling the session, the system is ready for execution.

As described above, the class and the composite class corresponding to the new processing request are generated, but these are held as the functional model 431 and used for assembling the system corresponding to the newer processing request thereafter. Will be done.

Next, the static world and the dynamic world will be described with reference to FIG. The real world (for example, the user's request) is
As shown by modeling in FIG. 6, an inclusion 402 giving specific information expressing the real world, and the real world 400.
Can be modeled by associating with the extensional name 401, which is a simple expression. In exchanging information, for example, in exchanging information about a certain real world 400, if the inclusive 402 of the real world 400 is understood by each other, it is an extension of the real world 400. It is enough to give the name 401. That is, it is not necessary to notify the other party of specific information, but it is sufficient to notify the other party of the name of the real world 400.

FIG. 9A is an explanatory diagram for explaining the static world and the dynamic world. In FIG. 9A, the inner package 402 is
For the above reason, as shown in FIG. 9 (A), information is generally hidden, and it corresponds to the “world of information hiding” 430. On the other hand, the real world expresses a mechanism about the real world 400 and a causal relationship in the mechanism, a “static world” 410, a temporal movement of the real world, and a plurality of sessions. Can be modeled with a "dynamic world" 420 that indicates whether or not to allow parallel processing of. Then, the "static world" or "dynamic world" and the above-mentioned "world of information hiding" are associated with each other by an extensional name 401, as shown in FIG. 9 (A).

Furthermore, the inclusion 402 is a world of information hiding and contains data defining the meaning of the extensional name. This extensional name, that is, an extensional name containing a certain meaning, is used to simulate the real world. that is,
It is a static model corresponding to the "static world" and a dynamic model corresponding to the "dynamic world".

FIG. 9B is an explanatory diagram for explaining the relationship among the static model, the dynamic model, and the functional model. Figure 9
The static model 411 shown in FIG. 9B is a model corresponding to the static world 410 shown in FIG. 9A, and the dynamic model 421 is also a model corresponding to the dynamic world 420. The information hiding world 430 shown in FIG. 9A is associated with the functional model 431.

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-combined class obtained by further compositing a plurality of classes) shown in FIG. 8 is designed in a corresponding form.

In the dynamic model, specific processing target units (instances) are formed by allocating the instance data in the above-mentioned class 302, and the temporal order relation between the respective 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.

Existing method 313 and class 302
Alternatively, the newly created class is retained as a functional model 431 and is used to build up a system corresponding to a newer processing request thereafter, and these methods and classes are dynamically built up as a system and used. Will explain the dynamic object processing.

FIG. 10 is a diagram for explaining a part of the operation in the dynamic object processing section. The above methods and classes are held in the component attribute file 205 as object components 206 as shown in FIG. 17 described later. The dynamic object processing unit shown in FIG. 10 performs processing using the object component. Needless to say, in the case of the present invention, it is possible to appropriately combine the object parts 206 as described above or the object parts 206 in a composite form.

Reference numeral 212 shown in FIG.
The object processing unit has a temporary operation mode 216 for performing a simulation and the like, an instant operation mode 217 for performing a test and the like, and a production operation mode 218 for performing data processing or communicating with another terminal.

Reference numeral 205 is a component attribute file, and reference numeral 205 'is an execution processing data file, which is used to perform a high-speed operation of the actual operation by compiling all or part of the content of the component attribute file 205. The execution processing data 214 is stored so that the execution processing data 214 can be executed. The execution processing data 214 is, in the case of an object program for processing execution,
In general, processing units consisting of several tens to several hundreds of steps are so-called serially combined in processing order.

Reference numeral 213 is the above-mentioned object, which is generally the same as the above-mentioned atomic object, the above-mentioned capsule object state, the above-mentioned event object state, or the above-mentioned event object state. Corresponding to each of the system object states. The object 213 is stored in the form of the object part 206 as specified by the object command.

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 collectively to obtain the execution process data 214.

As described above with reference to FIG. 2, the object is generally united in the form of a composite object into units to be processed, and becomes a unit that exhibits a behavior for executing a process having one certain purpose. Then, they are stored in the component attribute file 205 in the form of the object component 206 specified by the object command.

In the case of generating (corresponding to a new processing function) in the system corresponding to a new processing request, a new object is generated or a new object is generated so that the processing corresponding to the new processing request can be executed. The existing object is purposely combined and the object exhibiting the new processing function is the object part 2 described above.
It is prepared as one of 06.

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. 10, 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 provisional 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. 11) in actual operation. Is expanded into execution processing data (EXE data) 214 (compiled into one EX
E data). The expansion processing is performed by the illustrated direct object processing expansion processing 215 and stored in the execution processing data 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 direct object process expansion described above 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.
At 0, it is shown as instant operating mode 217.

Further, the production operation mode 218 shown in FIG.
Is a mode in which the actual processing operation is performed using the illustrated execution processing data 214. The component attribute file 205
As will be described later, in the meta data in the above, semantic data regarding the property of the object is described, and a higher-level object (an object indicated by “is-a”) viewed from its own object. It may be considered that there is a description instructing the connection relation of (1) and the connection relation of a lower-order object (object indicated by “part-of”) included in its own object.

FIG. 11 shows the structure of a terminal station. Code 1
Reference numeral 01 represents a terminal station which executes processing using the execution processing data 214 or communicates with another terminal station via a line. Further, reference numeral 103 represents a line such as a LAN or a switched line.

In the terminal station 101, there are further provided a communication / reception processing section 219, an object management section 220, a display 221 and a hyper language processing section 222.

The illustrated directory processing unit 204 is a command / link processing unit and is also called a directory processing unit. When one new object is created, a command (object command) corresponding to the designated name of the object is set, a storage location of the actual data 203 and the meta data 202 is allocated, and a 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, the meta data 202 and the actual data 203
Allows input and output of the combination with.

The (temporary operation support) shown in FIG. 11 is shown in FIG.
This is a support function corresponding to the operation up to the temporary operation mode 216 shown in FIG. The illustrated hyper-language processing unit 2
22 has a "part display / selection" function, which searches the display 221 for usable object parts and outputs them. If there is no suitable object, a new object part is designated by using the "part designation" function. A class / object part can be created by the "attribute setting" function, and an instance object part 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, (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, for the "component combination" function by the hyper language processing unit 222, that is, in order to combine object components to obtain a larger composite object component, an attribute addition / modification / deletion function for class creation is prepared. The function to add / change / delete schema is provided for creating instance constants.

In the "user screen creation" function by the hyper language processing unit 222, when creating and displaying a 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 (see FIG. 5) on the primary memory, and Try to execute the behavior that it has.

Further, the function of "part change" in the hyper language processing unit 222 has an internal schema 310 shown in FIG.
It corresponds to the function of the
It is a function to change object parts by adding / deleting. In addition, the "part registration" function is used for the part attribute file 2
05 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.
Direct object processing expansion processing 2 shown in FIG.
15 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. 11 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 2
17 and the actual operation mode 218 are performed. Also, in response to receiving messages via the line 103,
The instance is started in the temporary operation mode, temporarily encapsulated in the primary memory to operate the data processing device, and the result of the processing is sent as a message.
Of course, if there is already developed data in the execution process data 214, it is executed and the message is transmitted to the partner terminal station.

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 via the line 103. Receiving the transfer,
Learning is carried out at the place where it is taken into the own terminal station 101.

FIG. 12 is a diagram showing an example of generation processing of classes and instances in the internal schema. Reference numeral 2 in the figure
Reference numeral 03 is actual data (entity data), and 204 is a command / link processing unit.

Reference numeral 300 shown in FIG. 12 is a conceptual schema, which conceptually expresses 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 is related to a passenger car, it is considered that various methods related to a passenger car are variably incorporated and treated as one class. Reference numeral 303 is an instance, for example, class 3 related to passenger cars
This is a drawing showing a processing program created for a specific passenger car by giving individual specific data to the common name data used by each method loaded in 02.

Reference numeral 310 is an internal schema, which is configured inside the data processing apparatus as a schema corresponding to the above-mentioned conceptual schema 300. 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 describes method IDs of various methods that can be changeably incorporated into the class corresponding to one generated 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.

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. Consider the various methods (think of these methods that already exist) that the person (operator) who tries to generate the above as thinking about at that time as the methods required to generate the relevant class. . The considered one may be considered as the illustrated metaclass 301.

The operator inputs to the metaclass method 311 that the class relating to the passenger car is to be generated, and also inputs the above-mentioned various method names to the metaclass method 311.

Corresponding to this, metaclass method 3
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 on the class schema 312.

Corresponding to the generation of the class schema 312, each method ID has its own method 313, 314.
... is pointed to, 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, it may be considered that the metaclass method 311 is activated from the side of the class to be generated.

Furthermore, 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 on the instance schema 316. It should be noted that this operation may be considered to be performed by the operator asking the operator to input the respective instance data from the class side. Of these instance data, the data that has not been registered as the pop-up data 320 by that time is automatically registered on the pop-up data 320, and is available for subsequent use. Be prepared.

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 while generating a desired class, changing the method used in the class, and changing the instance data.

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

In forming a class, as described with reference to FIG. 12, in the class schema 312,
A class name is specified, and a method ID of a method used (modifiablely incorporated) in the class corresponding to the method setting is described. In addition, the method ID and each method 313, 314 ...
・ And can be 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, in the instance schema, the class name of the class that uses the instance is described, and individual instance data is described.

In response to the formation of the above class and the formation of the instance schema, the static world has a certain state table 4
Classes and methods chained under 14 and variables and constants 416 associated with each method are formed to exist. Also, if necessary,
It is related to other classes under the above-mentioned "is-a" relationship and "part-of" relationship. Further, 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 is specified. FIG. 13 is an explanatory diagram illustrating a state in which a class is generated from a metaclass. Reference numerals 300 and 31 shown in FIG.
0, 311, 312, 313, 314, 315, 316
Corresponds to that shown in FIG. Reference numeral 317 is a message transmission method, 318 is a gasoline cost calculation method shown as an example, and 319 is a sequence table provided in the object management unit 220. Reference numeral 220 represents an object management unit.

As described with reference to FIG. 12, the class name of the class to be created is set and the method used in the class is specified by using the metaclass method 311. At the same time, a message sending method 317 for the class to communicate with others is automatically set, and an 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, the instance that captures a specific instance corresponding to the class "car"
A schema 316 is prepared.

When 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 illustrated class name, and the sequence schema in the class schema 312 is captured in 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. 14 is an explanatory diagram for explaining the state of creating an instance from a class. The reference numerals shown in FIG. 14 correspond to those in FIG. As described with reference to FIG.
When the method to be included in the class is specified corresponding to the class 302, the class
Schema 312 is created and each method 313, 3
14 ... are 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 processes related to cars. It can be thought of as consisting of a group of methods for performing. And
By setting specific instance data in the data storage area of the class thus created, the instance (specific processing program in which the instance data is used) is created. The specific processing program is the illustrated instance.

When 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 22.
0 is the instance schema 316 and each method 31
3, 314 ... Is 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. In the example of the processing program, the class can be considered to be a processing program in which the instance data is still described in the form of a variable.

In the processing program in which 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 be a constant is the above-mentioned instance. By setting the instance data in the above instance schema 316 to be rewritable, a desired instance is appropriately created.

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

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

For this purpose, a verb (V in the figure) or a complement (C in the figure) that indicates the operation of the method is described together with the method itself (M in the figure) to form one object. The verb V and the complement C are referred to as method clothing in the present invention.

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

The clothing of an object provides a life cycle function for a method to act as an object independently. Having the life cycle function makes the object autonomous. That is, the garment is for the method selected by the operator through the extensional name to acquire the condition for enabling itself to operate. Briefly, it is for preparing the data acquisition means for instructing the operator the necessary data acquisition by the selected method itself.

The clothing of the object includes “life”, “open / closed”, “Input”, and the like shown in FIG.
In addition to "Onput", 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.

As described above, by the action of the class schema and the instance schema, it is possible to freely combine a plurality of existing and / or newly generated methods to build a system corresponding to a desired processing request. Will be done. However, each method and class stored as a functional model in the above-mentioned information hiding world 430 (these are all objects)
It is necessary to give consideration so that any operator who intends to use it at a later date can easily understand what functions each of these can perform.

Conventionally, there has been known a method of storing individual user data on a user data database and managing the individual user data by a database management system (DBMS). There is.

Also, conventionally, with respect to individual user data under the management of the above-mentioned DBMS, a meta data describing the property (meta data) of the individual user data.
Data database, data dictionary and directory system (DD / DS)
A method of managing the meta data is known.

In each of these methods, the user data managed by the DBMS and the meta data managed by the DD / DS are conventionally specified by, for example, a sequence number indicating the data order. . For example,
An object iD is attached to the user data managed by the DBMS and the object i
D was usually given by the above sequence number.

FIG. 16 shows the structure of a conventionally known database. Reference numeral 207 in the figure is a database, 2
08 is a database management system, 20
9 is a user data database, 210 is a data
Dictionary and directory system, 2
Reference numeral 11 represents a meta data database.

As shown in FIG. 16, conventionally, a user data database 209 for collectively storing user data has been constructed, and a database management system (DBMS) 208 centrally manages the user data. -Processes such as data generation, deletion, modification, and input / output. On the other hand, as the number of individual user data increases and the volume of each individual user data increases, the meta data will be explained in order to explain the role of each individual user data. Is created. And the meta
A meta data database 211 that stores data collectively is used.
Data dictionary and directory system (DD / D)
S) is provided.

In the present invention, the meta data and user data shown in FIG. 16 are collectively grasped as an object part 206. FIG. 17 shows a processing mode for handling an object.

The object component 206 in the component attribute file 205 shown in FIG. 17 is the user data in the user data database 209 shown in FIG.
It can be considered that the meta data in the meta data database 211 shown in FIG. 16 and the meta data are integrated into one. Of course, in the case of the conventional configuration shown in FIG. 16, a database management system 208 and a data dictionary and directory system 210 are used.
And were operating independently of each other. See also FIG.
The contents of the user data database 209 and the contents of the meta data database shown in No. 6 were individually accessed and used. In the case shown in FIG. 17,
The actual data 203 and the meta data 202 shown in FIG. 17 are combined and specified by an object command so that they can be handled as one object part 206.

Individual user data (entity data) on the user data database managed by the DBMS, and individual user data on the meta data database managed by the DD / DS. The idea of combining with the meta data of the above and handling it as an object part is being proposed.

Objects to be handled as the object parts include a so-called atom object, which is a minimum scale object, and a sequentially complexed capsule object, event object, system object, and the like. For this reason, the object to be handled becomes extremely complicated and complex, and when a certain object is given, what kind of property the object has,
In other words, the situation may be such that only the person in charge of generation can judge.

From such a situation, regarding the meta data and the entity data which compose the above object parts, the meta data has a descriptive text of the entity data, that is, a name, a comment, or meaning to a third party. A semantic data model to be understood, a general flow, a detailed flow, a source program, etc. will be described.

Therefore, the object parts generally have a sufficiently large amount of information, and it is desired to give the object parts a name for briefly explaining the contents of the object parts.

In the present invention, a name for explaining the contents of the object part regarding the object that can be compounded is given, and the object part can be accessed by the name.

FIG. 18 shows a block diagram for object management. Reference numeral 101 in the drawing denotes a terminal station which constitutes a data processing device, and 103 denotes a LAN or a switching line for communicating with other terminal stations.

Reference numeral 202 is meta data, 203 is actual data (entity data), 205 is a component attribute file, 206 is an object component, and 219 is communication /
The receiving unit 220 represents an object management unit. Further, reference numeral 214 is execution processing data, which is obtained by compiling one of the object parts or a combination thereof and expanding the data so as to be suitable for the actual execution processing.
Reference numeral 05 'represents the same as the component attribute file 205 and includes the above-mentioned execution processing data 214.

Reference numeral 201 shown in the figure is an object command given in the present invention, which is given as a name for specifying the above-mentioned object component 206.

The object command 201 is a signature (also called a surrogate) and an object iD.
The signature is made up of the following parts. That is, (i) header: Designates the number of bytes from the first byte to the number of bytes of a description area, an “is-a” layer, a “part-of” layer, a sequence, and the like described later. (ii) Explanatory text area: A summary of the explanatory text of the object, in which the original meta data of the object is compressed and described. For example, "Who made it?"
This is a compressed view of the portion corresponding to the explanatory text such as "what version?". (iii) "is-a" hierarchy: For example, when "dog is an animal", the relative position of the dog is expressed by hierarchizing the relationship between the lower "dog" and the upper "animal". is
In the −a ”layer, the lower“ dog ”is compared to the higher“ animal ”.
Etc. to indicate the situation that exists. (iv) “part-of” hierarchy: For example, “Honshu”, “Kyushu”, and “Shikoku” form a part of “Mainland Japan”. main land"
The fact that there is a structural relationship that a part of the above is configured is expressed by being positioned by the "part-of" hierarchy. (v) Sequence: A complex combination of objects (compound object) consists of many smaller objects. Such a portion that indicates the execution order (including branch) for a finer group of objects is compressed and expressed. (vi) Object iD: The same iD given to the data stored in the conventional user data database is given.

The object management unit 220 creates a new object part 206 in the part attribute file 205, modifies or deletes existing object parts, and integrates a plurality of object parts into a single object part. In addition to having a function of grouping into objects and dividing a single object part into a plurality of object parts, it also has the following functions.

That is, it has a function of communicating with a plurality of objects, ordering the processing order of each object, and performing the processing in accordance with a desired processing request. When performing such various processes, the object management unit 220
Specifies each object part by using the object command 201.

The group of object parts ordered as described above or the individual object parts are compiled as necessary to generate execution processing data 214, and the data processing in the terminal station 101 is performed. Alternatively, the execution processing data 214 is used in the communication processing with the other end station via the LAN or the exchange line 103 (because it is compiled, the file access etc. is small and the processing is speeded up). .

FIG. 19 is an explanatory diagram for explaining the relationship between a plurality of classes. FIG. 19A shows a case where a certain class X and another class Y have an "is-a" relationship. For example, a case is shown where the class X is a program related to “car” and the class Y is a program related to “passenger car”.

In the case of FIG. 19A, it is shown that the methods a, b, and c are incorporated in the class X, and the methods d and e are incorporated in 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, c, and The processing based on d and e is executed.

FIG. 19B shows a case where a certain class X and other classes α and β have a “part-of” relationship. For example, a case is shown where the class X is a program related to “car” and the classes α and β are one program such as “body”, “engine”, “wheel” ... ing.

In the case of FIG. 19B, the methods a, b and c are incorporated for the class X, the methods p and q are incorporated for the class α, and the methods r and s are incorporated for 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. It

As described above, the present invention grasps the system corresponding to a new request in the form of a class and an instance, and makes it possible to freely design the processing target, and to easily perform other processing later. To be available to. At this time, it is necessary to correctly deal with the constraint due to the causal relationship described with reference to FIG.

FIG. 20 shows an explanatory diagram for executing the processing.
As described above, reference numeral 401 in the drawing represents an extensional noun, and corresponds to the extensional noun shown in FIG. Further, reference numeral 403 is the world of procedures and corresponds to the comprehension shown in FIG. Further, reference numeral 404 is a world of objects, which is a world that models and represents the real world.

In modeling the real world (for example, a system corresponding to a new purpose), in the present invention,
A static world 410 indicating a mutual relationship of classes and / or methods required for the modeling, and a dynamic world 420 indicating a time sequence relationship of processing of instances obtained in the modeling are used. To do so.

The class and / or method designated in the static world 410, and a composite class in which the classes are composited are represented by a class 302 'for simplicity.

Reference numeral 302 is a class existing in the procedure world 403, 303 is an instance, 313, 314, ...
・ Indicates each method. The above method 313, ...
Is an existing processing unit that executes individual processing. The class 30 is a collection of a plurality of methods for executing more complicated processing from the group of the method.
It is 2. Further, if necessary, in order to perform more complicated processing from the class group or method group, the class or method may be imported to form a composite class. These correspond to individual objects.

It is assumed that these methods and classes already exist as existing ones. For example, it is assumed that a user requests a certain type of processing to process the processing target. At this time, in the present invention, the classes and methods required to process the processing target are taken in for the processing of the processing target, and the classes and methods are related to each other. It is the place of the static world 410 that describes the information relating these.

In the case shown in the figure, A, B, C, D, E and
F, G, K, L are taken in, (i) Class G and Class A are in an "is-a" relationship with Class E, (ii)
The class D has an “is-a” relationship with the class A, (iii) the class B has an “is-a” relationship with the class F, and (iv) the class D has a class D with the class B. Class K
Are in a “part-of” relationship, and (v) the class K and the class L are in a “part-of” relationship with respect to the class C. Actually, the class 302 'described in the static world is
3 is provided by using an ID sufficient to point to the class 302, the method 313, ...

The class 302 'is associated with the classes and methods existing in the procedural world 403, but simply speaking, it is a program such as a formula in mathematics for executing each process, The program may be considered to have values given as general variables in the program. The instance 303 is a specific program that sets instance data for general variables in the class and incorporates individual instance data.

In the dynamic world 420, the static world 41
The processing order requested by the user is executed by instructing the temporal processing order of the instances a, b, c, ... Corresponding to the class 302 ′ captured at 0.

If, for example, the user requests to process a certain processing target, classes A, B, C, D, E, and classes A, B, C, D, E, which are required for the processing in the static world 410, are given. F, K, L are designated. And between these classes, "is-a" and "pa"
A relationship such as rt-of "is clarified. In reality,
If a state table is prepared, their relationships are described, and there are causal constraints between the classes 302 ′,
That is also described.

In the processing for processing the above-mentioned processing target from the user, instead of using the imported class 302 'as it is, individual instances of the general variables in each class 302' are The instance 303 in which data is set is used. Then, the processing is performed according to the temporal order relationship in which each instance is processed.

In the illustrated case, an instance a corresponding to class A, an instance b corresponding to class B, and a class C
An instance c corresponding to, an instance d corresponding to class D, and an instance f corresponding to class F are generated, and (i) the session proceeds to instances a, b, and c;
(ii) Instances f, c, d, and a are shown as being presented with a session to proceed.

Needless to say, when the instance a is generated, the instance a is generated by using the class A corresponding to the formula. In this case, the class A is "is-a" for the class E. Because of the relationship, in generating the instance a, it is assumed that the class A is inherited the contents shown in the class E,
Generation is performed using both class E and class A.

When generating the instance b, the class D and the class K are "pa" for the class B.
Because of the rt-of ″ relationship, the instance b is generated using the class B, class D, and class K.

Furthermore, in executing each session,
For example, at the start of executing the instance a, the state table 414 shown in FIG.
Is executed and written to that effect, and when the processing of the instance a is completed, that effect is written to the above-mentioned state table. In this way, the constraint corresponding to the above-mentioned causal relationship existing in the static world 410 is not violated. Of course, a causal constraint due to the session being set up under the state where the individual instances a, b, c, ... Are newly generated, but this constraint does not apply to the session. It is given in association with each other. However, as described above, the causal relationship generated when the class 302 ′ is taken in and associated with each other in the static world is described in the static world 410, and may be inherited in session processing in the dynamic world. To be

FIG. 21 is a diagram for explaining a mode in which a causal relationship is incorporated in executing a session. Reference numeral 414 in the figure represents the same state table as that shown in FIG. In the illustrated case, it is shown that the information in the state table 414 includes the classes P to Y for a certain process, and the classes Q, R, S, and
It is shown that T, U exist, classes X, Y exist under class S, and classes V, W exist under class U. And the instances r, u, t, w,
s and x are generated and a session is set up.

Under the dynamic model 421, session I and session II are executed. However, it is not necessary to consider the causal relationship with other instances while each instance, for example, u, executes its own processing. The causal relationship is executed, for example, at the time when the instance u starts its own processing, by checking the contents of the state table 414, checking whether or not the constraint on the causal relationship is violated, and executing the processing of the instance u. It suffices to report in the status table 414 at the end.

When it is necessary to execute another instance v in place of the execution of the instance u in the session II as a result of executing the instance u in the session I, the instance u of the session I
On the basis of the execution completion report of (1), the instance u of the session II may be interrupted and branched to the instance v. Alternatively, the fact may be notified to the dynamic model 421 side when the instance u of the session II starts.

FIG. 22 is a diagram for explaining the relationship between the existence of a class and the process execution by the instance. As mentioned above
The state table 414 describes the templates and the causal relationships for the group of classes 302 ′. In the illustrated case, instances a, b, and c are generated corresponding to the classes A, B, and C as the loaded class 302 ′, and the instance b is generated by message communication in response to the end of processing of the instance a. Started, instance b
The instance c is activated by the message communication in response to the end of the processing. In creating a session in which the instances are combined, as shown in the lower part of FIG. 8 as (session creation) and (parallel operation timing) in FIG. 8, the operator gives an instruction, and the result is changed. It is described in the dynamic model and is used when executing the session.

FIG. 23 is a diagram for explaining a mode in which a causal relationship is checked in executing a session. Reference numeral 411 in the drawing represents a static model, 415 represents a causal relation constraint group, and 417 represents a receiving method. In the figure, uppercase letters such as A, B, P, Q, C, D, and E are classes 302 ′, and a, b, f, p, q, and
The lower case letters such as c and d represent the instances obtained by using the corresponding classes.

In the case of the figure, the following constraints are given in the causal relation constraint group 415. (A) Class A is restricted within self class A. A description of A = (blank) is given as _the constraint condition C _O. (B) The class P or the class Q can be started on condition that the processing of the class A is completed. As the constraint condition C ₁ , a description such as A → P, Q is given. (C) The class B can be started on condition that the processes of both the class P and the class Q have been completed. Constraint C ₂
, The description (P, Q) → B is given. (D) Class A is Class C or Class D or Class E
The process can be started on the condition that the process of is completed. As the constraint condition C ₃ , description such as C, D, E → A is given.

The constraint condition C as described above_O, C₁, C₂, C
₃Is given, the section in the dynamic model 421 is
When the instance a is started,
Through the acceptance method 417, the above-mentioned constraint condition C_ONo
C₃Is checked, condition C _O, C₃Is satisfied
Therefore, the process is started. And for instance a
At the end of processing t₂Via the accepting method 417
This is notified to the status table.

Then, for instance p and instance q
When the processing is started, the constraint condition C ₁Is satisfied
Is checked. Also when starting instance b
Because of constraint C₂Check whether or not
To be done.

As described above, in the case of the present invention, it is possible to generate a system for executing desired processing requested in association with template creation, class creation, instance creation, and session creation. , The system is executed, but the object management unit 220 (object management unit shown in FIG. 11 and the like) is allocated corresponding to each session, and each class or control JCL is assigned. Correspondingly, the object management unit 220 is allocated.

The object management unit 22 according to the present invention.
0 may be thought of as something like the following, rather than a single hardware device. That is, since the object management unit class is prepared as one of the classes referred to in the present invention, and the object management unit class (hereinafter, also referred to as ob tube class) is a class, the object management class is set as described above. The class is also a program like the above-mentioned formula in mathematics regarding object management, and by setting instance data corresponding to each session to general variables in the relevant object class, the object management unit instance (Hereinafter, it may be referred to as an obv instance) is generated for a plurality of times as needed. In addition, even when the class 302 and each of the control JCL and the like necessary for executing the session are corresponding, the obv instance is generated.

FIG. 24 is a diagram for explaining the hierarchical structure of the object management unit in the present invention. In the figure, reference numeral 220 is an ob tube, 220-1 is an ob tube of the first layer, 220-2
Corresponds to the second layer of tube, and 220-3 corresponds to the third layer of tube.

The first layer obv 220-1 is assigned with each session described above, activates the session, and controls the execution of the session. The second layer ob-tube 220-2 is associated with each of the plurality of classes 302 related to the execution of the session, and controls the execution of the process related to the class. Third layer of tube 220-
3 is, for example, “if then ... else” or “w
It is associated with a control JCL such as "hill ... for" or "go to" and performs the corresponding control.

In the description of the ob tube shown in FIG. 24, the ob tubes are shown to have a hierarchical relationship, but the ob tubes are equal to each other, and the hierarchies are related to the processing target. It only exists.

FIG. 25 is a diagram for explaining the mechanism of the obv tube. In the figure, reference numeral 220 is an ob tube, 220-1 is an ob tube of the first layer, 220-2 is an ob tube of the second layer, 22
0-3 is the same as the ob tube of the third layer, 220-3 'is the same as the ob tube 220-3 of the third layer, and the ob tube 220-3 of the third layer is the ob tube 220- of the second layer. Two
25, 224 is a sequence reading mechanism, 225 is a start processing mechanism, 226 is an end processing mechanism,
Reference numeral 415 represents a causal relation constraint group.

In each obtube 220-i, a sequence reading mechanism 224 for reading a sequence in response to an activation request to an assigned object or control JCL, and an execution target associated with the sequence are activated in order. It has a start processing mechanism 225 and an end processing mechanism 226 that manages the end of execution of each execution target.

Taking the ob tube to which a session is assigned as an example, the sequence reading mechanism 224 reads each of a plurality of instances forming the session and reads information such as the processing order of each instance. Operate. The activation processing mechanism 225 sequentially activates the obtube 220-2 corresponding to the class to which the instances to be sequentially processed belong so as not to contradict the causal relationship. Upon activation, the causal relation constraint group 415 is checked and then activated. Further, the end processing mechanism 226 receives the end of the process in the obtube 220-2 corresponding to each class, and outputs the result of the end of the process to the causal constraint group 4.
15 is notified and the causal relationship processing at the time of starting the start processing mechanism 225 is enabled.

The second layer obv 220-2 activated by the activation processing mechanism 225 in the obv 220-1 of the first layer changes the contents of the class so as to execute the process related to the class assigned to itself. Read and start the method that constitutes the class. At the time of activation, the above template is examined, and if there is a super class having an "is-a" relationship, genetic processing such as that shown in FIG. 19A is performed. See also "part-o"
In the case of the relation of "f", the genetic processing as shown in FIG. 19B is performed. Then, each instance for executing the above-mentioned session is generated. The operations of the read mechanism 224, the start processing mechanism 225, and the end processing mechanism 226 in the above are basically the same as those of the first layer obtube 220-1.

The start processing mechanism 225 in the second layer obtube 220-2 allows the third layer obv 220 to be executed.
-3 may be activated. Third layer of tube 22
Numerals 0 to 3 are for controlling "if then ... else", "while ... for", "go to", etc.
In the class processed by 20-2, the above "if the"
When processing such as n ... else ”becomes necessary, the third
The layer obtube 220-3 is allocated and activated.

Needless to say, in the present invention, a part of a static sequence (sequence that is not directly related to time order) in the static model or a dynamic sequence (sequence that is directly related to time order) in the dynamic model is used. The above change can be made in order to match the desired processing required in each case in a fine range, such as a partial change of). These changes need only be partially changed by the operator when assembling the above static sequence or dynamic sequence. When the changes in the static sequence are considered to correspond to spatial distortion, the changes in the dynamic sequence can be considered to correspond to temporal distortion. By partially distorting in this way, it is possible to easily deal with the request in each process.

FIG. 26 is an explanatory view conceptually showing the process of extracting knowledge data. In the figure, reference numeral 450 is explicit knowledge data, 451 is latent knowledge data, 452 is primary data, 453 is secondary data, 454 is an internal link within the same knowledge data, and 455 is to latent knowledge data. Internal links, 456 are mood links, 457 are abstract structural knowledge acquisition links, and each secondary data 45
Providing a mode in which knowledge is acquired within 3
Indicates a keyword and 459 indicates an external link.

The process by which a person extracts knowledge data can be considered as shown in FIG. There are two types of knowledge data, explicit knowledge data 450 and latent knowledge data 451, and in each of them there is surface data primary data 452 and black box knowledge secondary data 453. The primary data 452 may be considered as direct mapping data in the real world, and the secondary data 453 may be considered as data conceived in an abstract structure theory.

When considered in an actual system, the explicit knowledge data 450 corresponds to the data actually existing in its own terminal node, and the latent knowledge data 451 exists in the terminal nodes other than itself. It can be regarded as equivalent to data.

As a method of linking the above-mentioned data, there are an internal link 454 in the same knowledge data, an internal link 455 to potential knowledge data, and a mood link 456 connecting primary data and secondary data. When the latent knowledge data is obtained, it corresponds to the "satoru" action in humans. When this "satori" occurs, the latent knowledge data gradually shifts to the explicit knowledge data and "inspiring power". Can be obtained. In addition, link 45
6 was named the mood link 456 and the primary data was 4.
This is because 52 and the secondary data 453 are linked by a certain kind of intuition at that time or an association at that time.

In extracting the knowledge data shown in FIG. 26, it is started by acting on the primary data 452 in the explicit knowledge data 450 based on the keyword 458. From the primary data 452,
The internal link 454 in the same knowledge data expands the knowledge acquisition mode, and the internal link 455 to the latent knowledge data expands the knowledge acquisition mode to the latent knowledge data 451. Further, the secondary data 453 may be developed via the mood link 456.

Explicit knowledge data 450 in this situation
From FIG. 1 to FIG.
1 and FIG. 18, this corresponds to communicating with the other end station via the LAN or the switching line 103. In addition, the mode of acquiring the primary data 452 and the secondary data 453 in the explicit knowledge data 450 and the latent knowledge data 451 is as follows.
This corresponds to the processing shown in FIG. 8 and FIGS. 12 to 14.

The mode of knowledge acquisition by the abstract structure theory knowledge acquisition link 457 in the secondary data 453 is shown in FIG.
It can also be considered to correspond to an aspect of assembly by the conceptual schema 300 shown in FIG.

FIG. 27 is a diagram for explaining an object-oriented design mode existing in the undercurrent of the present invention. Reference numerals 410, 420 and 431 in the figure respectively represent the static world 4 shown in FIG.
It corresponds to 10, dynamic world 420, and functional model 431.

When a request for system design is generated from a user :: A problem corresponding to the request is described, and a scenario for summarizing specifications is created.

[0196] Next, an analysis is conducted, and what kind of data is required, what kind of method is required and available, etc. are summarized. : Based on the analysis result, in the static world 410, the work of extracting the required class will be performed, and the entity-relation (ER) diagram of the required data and the required method will be displayed. Entity-relationship (ER) diagram is created. The ER diagram is as shown in FIG. Then, the method for the schema is selected based on the ER diagram of the data, and the data and the method are correctly associated with each other based on the ER diagram of the method.

When the ER diagram of the method is obtained, the class is created and registered as shown in FIG. 8, FIG. 12, FIG. 13 and FIG. 14 based on this. In addition, a compound class is created.

In the dynamic world 420, a flow chart for related events is created, and events that can be processed in parallel are determined. And FIG.
The instance is created and the sequence is designed as shown in FIGS. 12, 13, and 14. In addition, causal relationships are extracted in connection with the determination of events that can be processed in parallel,
The causal relationship is as shown in FIG. 8 and FIG.
Set to and reflected in the static world.

The user's request is dealt with based on the instance obtained as described above, but the class, the composite class, and the instance obtained during this time are processed by the functional model 43.
Retained as 1 for future reuse. Also,
When creating the above class, for the methods that are in short supply for the time being, they are registered in order to create and use the insufficient methods and to prepare for future reuse. The creation of the missing method is performed by the processing shown in FIG. 8, FIG. 10 and FIG. 11 (processing of the hyper language processing 222 shown in FIG. 11). Try the temporary operation to improve while combining the parts. In addition.

FIG. 28 is a diagram for explaining the manner in which objects are used. The right half of FIG. 28 corresponds to FIG.
This corresponds to the processing in the static world 410, the dynamic world 420, and the functional model 431 shown in FIG. See also FIG.
The left half of 8 represents a technique for combining object parts.

The free combination technique 480 of object parts in the left half of FIG. 28 is shown in FIG.
2 corresponds to the processing shown in FIGS. 13 and 14. The creation 481 of the meta data corresponds to the creation of the meta data shown in FIGS. 15, 17, and 18. Furthermore, FIG.
The object command 201 shown in FIG. 8 is the object command shown in FIG. 18, and is generated corresponding to each object part 206 that is a set of meta data and actual data as shown in FIGS.

The generated object command 201
Are automatically organized and made freely available, as shown in Figure 2
It is used in the question tool in the reuse technique of the right half object part shown in FIG. That is, the object
Object part 2 required based on the command
06 is called and reused.

FIG. 29 shows the manner in which object parts are created by spec-oriented processing. (A) When a specification (specification corresponding to a new processing request) is given, keywords are linked by association.
That is, keywords that are fuzzy are drawn out. The state in which this operation is performed may be considered to be performed by some kind of “inspiration”. (B) The terminal station notifies the other terminal stations on the LAN or the switched line of the obtained key wad. This operation is performed by communication such as broadcasting. (C) From each terminal (workstation WS), the corresponding object part 206 or object command 2
Collect 01. (D) From the object parts 206 existing in each terminal station, the one that matches the current specifications is obtained. (E) A sequence is assembled and schematized so as to meet the current specifications.

The object-oriented data processing system of the present invention configured as described above can be a powerful support system for the system designer to construct the system, as is clear from the above description. it can. In order to realize such super-partization of object parts, as shown in FIG. 30, WHD theory (structure theory of objects), combination technology (hyper language processing part 222).
It is necessary to use new technologies such as composite object generation technology based on the above), self-PR technology (object self-PR technology), and reverse link technology (automatic program change technology by gene manipulation). By combining the top-down and bottom-up of the above, as shown in FIG. 31, efficient reuse of objects can be achieved by the various devices described above and the teamwork of the devices described below. It will be. Next, these points will be described.

First, the structure of the atom object specified for realizing the super-partization of the object parts will be described. In order to support system design by system designers, it is necessary to reuse objects.
To this end, the atomic object, which is the basic unit of the object, has complete independence encapsulated because it is used for everything, has parameterized abstraction as much as possible, and has normality without redundancy. , And orthogonality that allows combination with other components, and a drastically simplified series logic.

FIG. 32 is a diagram for explaining a method of giving independence to atomic objects. In the figure, reference numeral 411 is a static model, 421 is a dynamic model, 414 'is a causal relationship table, 4
Reference numeral 15 is a causal relationship constraint group, 422 is a causal relationship processing program, and 423 is a causal relationship check function.

As one means for giving independence to atomic objects, the causal processing is left to the processing of the causal processing program 422.
In other words, even if a relationship that requires exclusive processing is assumed among the atomic objects, the atomic objects are obtained by disregarding the relationship, and the causal processing is not performed for each atomic object. This is dealt with by the processing of another causal relationship processing program 422.

In FIG. 32, an instance a created for the atomic object A, an instance b created for the atomic object B, and an instance c created for the atomic object C are shown. The causal relationship check function 423 checks whether or not there is a causal relationship during the sequential execution, and the causal relationship processing program 422 checks the causal relationship table 414 ′ and controls the processing by the illustrated composite instance. In other words, the atomic objects A, B, and C are given independence by disregarding relationships such as exclusive processing. Also, do not consider the design of common resources in the case of static models, dynamic models, and functional models, and link them freely between the soft sensors after the design is complete, and freely specify the attributes. Allowed to be added.

FIG. 33 is a diagram for explaining a method of giving orthogonality to atomic objects. Reference numeral 213-2 in the drawing represents an atomic object. Each atomic object has a self-PR function, and has a function of notifying an operator of what type of self-object and what data is needed.

In order to give orthogonality to the atomic object 213-2, automatic alignment of arguments is enabled so that any combination can be combined. FIG. 33 shows a situation when the atom object 213-2 (# 1) and the atom object 213-2 (# 2) are combined. That is, the atom object 213-2 (# 1) emits the argument “1”, and the atom object 213-2
Assume that (# 2) requires the argument "2". In this case, the atom object 213-2 (# 2) makes an addition request when the arguments from the atom object 213-2 (# 1) are insufficient, and when there are excess arguments, the atom object 213-2 (# 1). ) Will receive the argument as it is. During this period, the self PR function of each atomic object notifies the operator. Then, when the addition is required, the operator is requested to perform the addition to perform the argument matching. Also, the operator is instructed even when the types of objects are different.

FIG. 34 is a diagram for explaining a method of giving normality to an atomic object. Reference numeral 213-2 in the figure is an atomic object, 701 is an enversion processing mechanism, 7
Reference numeral 02 represents an enoversion list.

While the atom object is being created,
For example, the atom object 213-2 (P), the atom object 213-2 (Q), and the atom object 213-2
(R) and ... are supposed to exist. And each atom object occupies most of the whole figure.
It is assumed that the shaded portions shown in are the same and that the unique portions are the "P" portion, the "Q" portion, and the "R" portion.

In such a case, the enoversion processing mechanism 701 knows the occurrence of the state and modifies the atomic object as follows. That is, each atom object 2
13-2 (P), 213-2 (Q), 213-2 (R)
The atom object 213-2 (A) corresponding to the superclass is generated corresponding to the hatched portion common to the ... Then, for example, the atom object 213-2 (P)
In step 1, the peculiar portion “P” is left, and it is instructed that the superclass of the atom object 213-2 (P) is the atom object 213-2 (A). Of course, atomic object 213-2 (Q)
And 213-2 (R) ... By doing so, the atom objects 213-2 (P), 213-2 (Q), which are mostly approximate,
213-2 (R) ... Are grouped under the superclass atomic object 213-2 (A), and are described in the enoversion list 702. Needless to say, the relationship between the atomic objects 213-2 (A) and the other objects summarized as shown in FIG. 34 may be “is-a” or “part-of”. However, even with other relationships, genetic processing as shown in FIG. 19 is performed as necessary.

FIG. 35 is a diagram for explaining a method of giving abstraction to an atomic object. Atom object 213-
Atom object 213-
Corresponding to 2, a model as shown in FIG. 35 is given. That is, what (WHAT) is given as an input to the buffer (WH
The AT is instructed, the buffer (HOW) is instructed what (HOW) processing is to be performed, and the buffer (DO) is instructed what the processing result is (DO). Needless to say, each buffer (WHA
T), buffer (HOW) and buffer (DO) need not be considered to be fixedly prepared for each atomic object. For example, when the atomic object 213-2 shown in FIG. 35 is given as having a function of “converting a numerical value into a character”, a buffer holding the numerical value (the buffer is also one of the objects and is called a buffer object). ), A buffer object for storing characters, a buffer object for conversion, and
Try to give a transfer of information between objects.

FIG. 36 is a diagram for explaining giving a series logic property to an atom object. For example, in FIG.
If an object with a branch as shown in 6 (composite object in this case) exists, the part corresponding to the “branch” is the control object (one of the atom objects) and the other diagonal lines are shown. Cut out the part that is a non-control object. If cut out in this way, there will be no branch where each non-control object exists, and each non-control object will have series logic. Then, whether or not to leave each of the non-control objects as one of the atomic objects is considered.

In FIG. 36, a functional object (hatched in the upper right of the figure) is present as a non-control object, and an abnormal processing object corresponding to the abnormal processing (shown with cross hatching). Is present as an example. Further, for example, the function object is associated with the buffer object as described with reference to FIG. 35, and there is a domain check object for checking up to which range the buffer object is applicable. This is illustrated.

As described above, each atom object is generated in a form in which the types are summarized as much as possible. The following types of atomic objects may exist, for example.

• Area reservation • Name registration
・ Read ・ Write ・ Error processing (multiple) ・ Control
-JCL-Calculation-Timer-Image schema registration-VC control-Domain check processing (plural)
・ Data reading ・ Data output ・ Data comparison ・ Data rewriting ・ Hard sensor ・ Hard actuator ・ Alarm processing etc. The number is preferably about 100, and at most 500 or less.

FIG. 37 is a diagram for explaining a situation in which abstraction is given to a composite object. Reference numeral 213-2 in the drawing is an atomic object, 213-3 is a compound object, 21
Reference numeral 4 represents execution processing data.

Atom objects A, B, C ... Used in the compound object 213-3 and compound objects (A → B → C) are not directly incorporated in the compound object 213-3. , So to speak, the respective atomic objects 213-2 (A), 213-2 (B), 213-by the pointers from the positions where the respective objects A, B, C ...
2 (C) ... is pointed. In actual processing, the atomic object 213-2 (A), 2
13-2 (B), 213-2 (C) ... Are incorporated in the execution processing data 214. By adopting such a configuration, the abstraction is given to the composite object 213-3.

All atomic objects are made up of procedural programs. That is, the atom object is
It is, so to speak, a method object. The reason why this method object is called an atom object is that the atom object is "input data +
This is because it is created in a logical three-stage format (sometimes referred to as WHD structure) "processing + output data". And, all of these three steps are parameterized, and the atomic object program is abstracted so that only those that process the flow are prepared. That is, even the processing is parameterized, and it is only one processing. As the types of the WHD structure of this atomic object, as shown in FIG. 38, comparison type, confluence type,
Five types are considered: a shunt type, an END type, and a START type.

The input conditions of this atomic object are roughly divided into a default value (order value) and a flow value (message value). In the default value, a true constant value is set. Sometimes it reads the buffer value. The latter buffer value is treated as an order value because it goes to get the specified data. The flow value includes a processing result value and a jump value. The former processing result value is the data of the previous component lined up in the sequence, and the latter jump value is the value connected in a causal relationship. The jump values are synchronized due to the causal relationship. Then, the output condition of the atom object has a buffer value and a method value.

On the other hand, a compound object created by combining atomic objects, a compound object created by combining atomic objects and existing compound objects, and a compound object created by combining existing compound objects are ,
Structurally, this compound object, which is generated as a combination of atomic objects and is represented by a list structure of atomic objects, has the atomic object control component (as described above and shown in FIG. 39). Connect with control JCL),
It will be executed by creating objects such as classes and sessions. Note that the causal component used for synchronization functions as a component for nameless connection. Due to this causal part, parts far away,
Any component can be connected, giving it flexibility. FIG. 40 shows an example of the control component. Then, this compound object is also processed so as to have the same WHD structure as the atomic object, as shown in FIG. 41, in order to enable combination with other objects.

As described with reference to FIG. 18, the metadata is
It is symbol-compressed as a kind of genetic information called the signature of object command, and naturally, it has a certain role in society or system. The nature of this gene is that each one is an attribute and a method, and if one of them becomes NULL, one more superclass becomes one
You can have a higher super class. In this way, the hierarchization of parts by genetic manipulation is executed. On the other hand, reversing this operation and replacing one of the genes with another causes association, and addition causes creation. This association is
On the contrary, it is a form of newly creating a superclass, and creation is a form of newly creating a subclass.

By structuring the object with WHD,
It will not be necessary to pass arguments between objects. As shown in FIG. 42, for example, when executing the processing corresponding to each of the instances a, b, and c, the command / link processing unit 204 illustrated in FIG. 11 is involved and the arguments are automatically passed. . That is,
In the processing corresponding to each instance, it is only necessary to arbitrarily write or read the common resource. It suffices to guarantee that the instances a, b, and c are executed serially, and the process corresponding to the instance a illustrated in the figure writes the data d ₁ and the process corresponding to the instance b reads the d ₁ . And are synchronized.

As described above, the causal relationship is introduced to give independence to the object, but the command / link processing unit 204 is also greatly involved in realizing this independence. That is, the independent object is the WHAT command / link processing unit 204.
This is because the data is read from and the DO is written to the command / link processing unit 204.

FIG. 43 is a supplementary explanation for FIG. Even if the process corresponding to the instance a and the process corresponding to the instance b are synchronized in FIG. 40, the data d ₁ in the process corresponding to the instance a is correctly input in the process corresponding to the instance b. Whether or not there is a problem.

It is desirable not to pass the argument each time, but some measure is required for that purpose. Therefore, in the case of the present invention, when the hyper language processing unit 222 assembles the instances a, b, and c into a session in advance, the output d of the instance a is output.
Let ₁ be used as the input in instance b. By doing so, in the above example, it becomes possible to eliminate the passing of arguments between the processes corresponding to the respective instances. Furthermore, it is sufficient that the hyper-language processing unit 222 sets only the names of the arguments together, and the command / link processing unit 204, so to speak, writes / reads.

Next, a combination technique prepared for realizing the super-partization of the object parts will be described.
This combination technique is a technique in which the hyper language processing unit 222 generates a compound object from an atom object, as shown in FIG. The basics of this combination technology have been explained so far, so I won't go into the details, but create a new compound object by combining atomic objects, and
A new compound object is generated by combining an atomic object and an existing compound object, and a new compound object is generated by combining existing compound objects. In order to realize this combination, as described above, the atomic object and the compound object will be configured to have the same WHD structure.

To realize this combination, compatibility diagnosis is executed so that the arguments match. That is, FIG.
As shown in 5, an atomic object of class A and
There is a class A that has an HOW called process name A '(using parameters pp and qq) when an atomic object called class B and an atomic object called class C are combined to generate a compound object called class X.
Class with the a _1, a ₂ are WHAT input data, and _{a 3, a 4, a 5} , a 6 is a DO of the output data, processing name B 'and HOW that (parameter rr, the use ss) of and b _1, b _2, b ₃ is WHAT input data B, and b _4, b ₅ is a DO of the output data, processing name C '(parameter t
c _1, c _2, c _3, c ₄ which are WHAT of the input data of class C having HOW of (using t) and the DO of the output data.
Between c _5, c _{6 and} c ₇ , which are DO, α ₁ which is the output data of the class α at a distance, and β ₁ which is the WHAT of the input data of the class β at a distance. When there is an argument passing relationship as shown in the figure, the argument passing relationship is registered in the temporary command file by interacting with the system designer. At this time, when a request for a relationship of argument passing is made despite the difference in type, it is configured to reject it.

The class X of the composite object generated in this way is, as shown in FIG.
In addition to having the input data a _{1 and} a ₂ and the output data c _{5 and} c _{6 , the} data are degenerated into those having a causal relationship between the classes α and β. However, a ₁ is specified as an order value to be given by an instance.
It is easy to grasp these in my mind that the command / link processing unit 204 executes the read / write processing of the input / output data completely independently and that the synchronization condition is set in the causal processing. This is because the idea of doing it is the basis.

When the class X is instantiated, an instance as shown in FIG. 47 (a) is generated. Here, O-id to a _1, as an order value in the attribute constant /
O-id is given. This instance is an object whose input interface is a _{2 and} whose output interface is c _5, c ₆ . When this is used for a session,
As shown in FIG. 47 (b), it is reborn as x ₁ .
The session S ₁ illustrated in FIG. 47B is made up of interfaces x ₁ , y ₁ and z ₁ , and a causal relationship is established between the sessions γ ₁ and γ ₂ .
The d _{1 of} y ₁ and the e ₁ of z ₁ are the message data changed to order data when the session S ₁ is created. The change of the message data into the order data in this way may also occur when the subsystem SS ₁ as shown in FIG. 47 (c) is created.
When changed to the order value, the data becomes invisible externally. This is because it is processed as default data.

The hyper language processing unit 222 preferably implements this combination technique in the screen language. For example, as shown in the processing flow of FIG. 48, the table of contents of the parts required for combination is displayed, and when the system designer selects the parts, the parts are displayed in the logo format as shown in FIG. , Input data, output data, and HOW parameters are displayed in association with the logo display, and the order mode (substantial value can be set when creating an instance) for those data, or the message mode (session creation) It becomes a parameter that determines the sequence at the time of)). Then, by interacting with the system designer, the connections between the parts are set and displayed with lines, and the connections with the parts with a causal relationship are set and displayed with lines. This is achieved by setting attribute values and displaying those values. Here, when connecting the components, when the system designer gives an instruction to connect the arguments of different types, the connection instruction is rejected.

In this processing, the present invention employs visual processing of screen driven control. In the view processing up to now, as shown in FIG. 49A, the screen has a configuration in which it waits for an event from the processing function to move. That is, an operation called process driven is performed. On the other hand, in the visual processing of the present invention, as shown in FIG. 49 (b), when the user instructs the screen, the screen driven control is employed, which becomes an event and activates the processing object. is there. With this configuration, when the created screen logo is replaced with another one, the genetic information of the object signature (which describes the binding relationship between objects) is automatically changed, and the program structure also changes. become. When actually moving, as shown in FIG. 49 (c), when the processing object is activated for some reason, the user sets the mode to the screen driven processing to enter the screen driven mode, and when the screen object moves, The screen-driven processing is executed by notifying the processing object of the result.

Further, in the present invention, when implementing this combination technique, a configuration that uses the past combination result is adopted, or a configuration that automates this combination technique is adopted. FIG. 50 shows an example of such a configuration.
The production rule file in the figure manages the combination information of the objects for which the compatibility has been established and the combination information of the objects for which the compatibility has not been established, and the structure parts represented by the structure class are of the sequence structure. It represents an unspecified enumerated part, the sequence part represented by the sequence class represents the part whose sequence structure is specified, and the compatibility check rule set is established between the objects. It manages the compatibility rules. This compatibility check rule set is prepared, for example, by extracting compatibility rules from combination information of compatible objects managed by the production rule file.

51 and 52 show an example of the processing flow to be executed by the present invention when the object parts are combined. The processing flow of FIG. 51 is a processing flow executed when an object of a sequence component is given. First, step 1
Then, the combination data (object data of the sequence part) is read, and then in step 2, it is searched whether or not the read combination data is registered in the above-mentioned production rule file.

When it is judged in the following step 3 that the search result is judged and the read combination data sequence is registered in the production rule file as being compatible, the process proceeds to step 8 and the object of the combination data is searched. Determines whether or not the object has a causal relationship with another object, and when it judges that the object has a causal relationship, the process proceeds to step 9 to execute a combination process with the object having the causal relationship. To do. At this time, the hyper-language processing unit 222 adopts the configuration of displaying the object in the logo format as described above, and executes the combination processing by interacting with the user. When it is determined in step 3 that the sequence of the read combination data is registered in the production rule file as incompatibility, the fact is displayed to the user and the process ends.

On the other hand, if it is determined in step 3 that the sequence of the read combination data is not registered in the production rule file, it means that the combination check has not been executed in the past, so the process proceeds to step 4. , The hyper language processing unit 222 tries to combine objects by connecting arguments. At this time, the hyper-language processing unit 222 adopts the configuration of displaying the object in the logo format as described above, and executes the combination processing by interacting with the user.

When it is determined in the following step 5 that this combination result is not combinable due to a mismatch of arguments in the read combination data sequence or the like, the process proceeds to step 6 and the read combination data is invalidated. Therefore, the natural selection is performed and the combination data is registered in the production rule file as incompatibility. On the other hand, when it is determined in step 5 that the read combination data sequences are combinable, the process proceeds to step 7, the combination data is registered in the production rule file as compatibility, and in the subsequent step 8, the combination is registered. When it is determined whether or not the object of the data has a causal relationship with another object, and when it is determined that the object has a causal relationship, the process proceeds to step 9, and the combination with the object having the causal relationship is established. Execute the process.

In this way, by executing the processing flow of FIG. 51, when the object of the sequence component is given, while referring to the past combination processing result,
The combination processing of the objects is executed to generate new objects.

On the other hand, the process flow of FIG. 52 is a process flow executed when an object of a structure part is given. First, in step 1, the structure data of the combination is read, and then step 2
Then, create a matrix of the combination of the read structure parts. That is, the sequence parts are created according to the matrix of the read structure parts.

Then, in step 3, one of the created sequence parts is selected, and the compatibility relationship between the objects of the selected sequence part is checked using the compatibility check rule set, and the compatibility of the arguments is confirmed. Matching sequence parts are given compatibility and are born as valid objects, and are registered in the production rule file to notify the user. Then, in the following step 4, it is determined whether or not the processing has been completed for all the created sequence parts, and when it is determined that the processing has not been completed, the process returns to step 3.

By executing the processing flow of FIG. 52 in this way, when an object a, an object b, and an object c are given as shown in FIG. 50, “a → b → Objects having a causal relationship with the objects α and β having the sequence structure “c” are automatically generated.

Next, the self-PR technique prepared for realizing the super-partization of the object parts will be described. As shown in FIG. 53A, this self-PR technique is a process of presenting the metadata of the object created by the hyper language processing unit 222 to the system designer. According to this self-PR technique, the system designer can specify the objects required for system design.

There are roughly two types of self-promoted data. One is semantic data and the other is management data. Furthermore, there are two pieces of the former semantic data, one is structural gene information that constitutes a program purely, and the other is name data set to supplement their explanation. This name data is also divided into simple words and schema words as shown in FIG. 53 (B). This semantic data includes keywords, flows, parameters, comments and the like. On the other hand, management data are mental genes necessary for management.

Details of the self PR function will be described below with reference to FIGS. 54 to 59. FIG. 54 is a schematic explanatory diagram of the self-PR function according to the present invention.

When the operator issues a use request to the group of parts from the display, the self PR function allows each part to carry out self PR by itself. The contents are the following 3
It is divided into two items.

Function for inquiring about variables held in each part and requesting input Function for publicizing the purpose, type, comments, etc. of parts according to the operator's request Function for teaching program specifications in response to questions ,
The contents to be taught include detailed explanation, outline explanation, meaning data, management data, usage and the like.

Although a part of the above is explained with reference to FIG. 15A, the information used also for the self PR is extracted by the clothing (roll) function of the object. In addition, the number of information items is the largest, which is given by the component attribute file.

FIG. 55 is an explanatory diagram of the clothing function of an object. As shown in FIG. 55, the clothing function of an object is a function of converting it into an object by passing a program (a normally created program may be used). When made into objects, a list of buffers used by the programs used therein (a in FIG. 55) and a comment list (b in FIG. 55) are created. This is registered by taking the O-iD of the metadata in the component attribute file. As a result, the buffer used by the component at any time (the buffer used by the program)
And you will be able to look up comments.

The objectification by the clothing function includes the atomic objectization processing (c in FIG. 55). Atomic objects are hyper-parts, and have independence, orthogonality, abstraction, simplicity, and normality. In other words, this atomic object processing is to make the buffer of the program NULL (flags and real numbers
L) and control parts (eg if t
(Hen, While for, etc.) is removed, it is replaced with the control in the super component, and the separated program is divided into each one.

The information used for the self-PR function of the part includes the above-mentioned three types, all of which represent the property of the part (object) as metadata. As described above, the object component, the metadata, and the user data are a set of the metadata 202 and the actual data (user data) 203, and form one component (object).
Configure 206. This metadata 202 is almost automatically created, but the above data is given by the clothing function of the object as described above (FIG. 55).
Data is provided by a component attribute file (which is automatically created by SPEC orientation).

The metadata information of the parts will be described here. As described above, the metadata information is automatically created by the clothing function of the object and the hyper-language processing unit 222, and the introduction of the use buffer and the purpose (name of the part) And a brief introduction or comment in the program) and the genes contained in the component attribute file. This gene has a name, a keyword (including abbreviation), a description,
There are old metadata data (data for management), semantic data, spatial connection, temporal connection, component (atom object), and the like.

The semantic data is manually input because it is difficult to automate it because the parts are grasped by the abstract concept. The spatial connection represents the link data of the composite class, and the temporal connection represents the link data of the composite instance. Then, the component as the entity of the component is represented by an aggregate of atomic components and composite components. However, if you search for deep signature links, they will eventually be represented by atomic components.

FIG. 56 is a diagram showing the construction of a component attribute file for self PR and PR processing. There are roughly two methods considered for the component creation processing. One is user data processing, that is, hyper language processing, and the other is SPEC-oriented component creation processing. FIG. 56 shows an example of the hyper language processing, the contents of which will be described below.

In the hyper language processing 222, the operator operates the display (input / output terminal) 221 to operate the atomic object 213a and the compound object 213.
b is used to create a class (or composite class) 302, an instance 303, and a session 606. The information at that time is automatically assigned by the automatic sorting function 608 as the metadata 202 of the component of the component attribute file 205. There are seven types of information to be assigned, which are roughly classified by the symbols A to G, and each will be described below.

A: Component name This may be set by the program or may be input by the operator.

B: Component iD Since this is a common word that moves internally, it is automatically given by the user data processing.

C: Metadata This data means management data in the old metadata (metadata of the original part used when creating this time). It relates to DD / DS (210 in FIG. 16) such as who, when, what kind of change, what purpose, etc., and is divided into those that can be automatically created and those that are manually input.

D: Semantic data This is data expressing the contents of the program, and in most cases, it is manually input. However, the attributes when creating a class are automatically entered.

E: Data of keyword (KW), description, flow, source, etc. In KW, the attribute name and part name are automatically input, or if the name is desired by the user, it is manually input. It
The explanation and flow are SPEC oriented, and the source is automatically input.

F: Structure data This is a combination of atomic parts and sequence data, and is input from the hyper language processing.

G: Entity data iD As described above, the metadata of the component in the component attribute file is
Hyper-language processing and SPEC-oriented processing (not shown)
About 90% is automatically created and input to the file. The operator re-inputs the remaining data and the data that is difficult to automatically create by the data input processing 609 from the display 221. Among them are the names of the above-mentioned parts, some old metadata, semantic data, KW, explanations, flows and the like.

The self PR processing 610 outputs the data of the parts attribute file and the contents of the parts (including the source of the program) corresponding to the requested contents when the request is made in the conversation form by the operator, and inputs the necessary data. , Assists in the creation and operation of new programs using existing parts.

FIG. 57 is a flow chart at the time of program registration by the self PR function, which is executed at the time of registration of the program created by the configuration shown in FIG. When the program is registered, only the program or the buffer is taken out, and it is put together in a structure, and at the same time, only the comment is taken out in the structure, and further metadata and the like are input (S1 in FIG. 57). Next, if there is a usage request,
The structure of the buffer is displayed and the data value is input (at step S2). An instance schema is created from these results (at step S3).

FIG. 58 is a block diagram of functional blocks for self-PR. Functions b, c and d in FIG. 58 correspond to the process S1 of the flow shown in FIG. In FIG. 58, for the program a to be registered, the function b for extracting the used buffer, the function c for extracting the file and the function c for extracting the comment, and the input function d of the metadata, the semantic data and the flow, and the source work Registration f is performed. In this case, the display function e on the display controls the display of the contents of each file and the screen display for input, and the operator can input the contents interactively while watching the display on the display. Also, by making a request to the registered program by self-PR, processing such as display and input of the content of the corresponding program is performed, the program is registered using the existing program, and the program is registered. Compile g
The execution program (EX
E program) h is created.

In the present invention, the output of each data of the part attribute file becomes the self PR function of the part. The self PR function is dynamically and interactively output (advised) when the hyper language processing shown in FIG. 56 is operated. For example, when creating a class from a metaclass, you must advise checking the orthogonality of atomic object combinations. When creating an instance from a class, you must request the parameters needed for the configuration. At the end of the session, causal advice is needed. At this time, if the meaning, purpose, movement flow, source, structural data, etc. of the part are requested, it is possible to give advice (help) using the data of the part attribute file.

FIG. 59 is an operation flow chart for creating a program using the self PR function. In FIG. 59, reference numeral 510 denotes a self-PR function unit, which interactively outputs data in response to a request using the metadata of the above-mentioned component attribute file with an operator.

Explaining the processing, when the operator makes a use request for a part (object) (S in FIG. 59).
1), the self-PR function unit 510 outputs the name of the registered component (S2). In response to this, the contents of the parts are displayed on the display (at step S3). When the operator selects one component from this table of contents and issues a component use request (at step S4), the self-PR functional component 510 checks the variable desired to be set for that component and requests data entry. (S5). In response to this, the variable name of this part is displayed on the display (at step S6). On the other hand, it is determined whether the operator has input a question (at step S7), and if there is a question, the content of the question is queried (at step S7).
8). The self PR function unit 510 extracts and outputs the corresponding content in response to this (step S9). That is, contents of variables in the program, comments in the program, contents of metadata, contents of specifications, flows, contents of sources, and the like.

The output contents are displayed, and it is judged whether the contents are a part (object) (at the same step S10), and if it is a part, data such as a variable corresponding to the part is input (at the same step S11). If it is not a part, the process can return to S8 to ask further questions. When data is input, it is checked that the data meets the predetermined type and definition (S12), and if not, the input request is displayed to the operator (S13). ). If the check is good (OK), the part (program) can be operated.

According to this self-PR function, the system designer can select a part suitable for the newly created program from the existing registered parts (objects).

Next, the reverse link technology prepared for realizing the super-partization of the object parts will be described. This reverse link technology has a function of automatically changing an object by manipulating the gene of the object, and will be prepared to generate a new composite object required for system construction.

FIG. 60 shows the configuration of this reverse link technique. This reverse link technology is a technology that changes the metadata and actual data of an object according to screen-driven, and visualizes genes, and the system designer deletes or adds to the visualized genes. This is a technology that associates and creates a new object by changing the metadata and the actual data pointed to by the genetic manipulation of. For example, by exchanging some of the genes in the structure of connection of multiple objects, association is executed,
Creation is executed by adding a new gene to the gene. As shown in this figure, the hyper language processing unit 222 activates visual processing, and thereafter,
The hyper language processing unit 222 will be driven in a screen driven manner. The gene data is the hyper language processing unit 2
After the metadata is created at 22, it is automatically created separately from screen-driven.

FIG. 61 illustrates this genetic manipulation process. FIG. 61 (A) shows a hierarchical structure of object parts by genetic manipulation. When only one becomes NULL, the superclass one level above becomes one, and when it becomes one, the superclass one level higher. It is shown that the object parts are layered by the genetic manipulation such that "." Further, in FIG. 61 (B), association is caused by deletion or replacement of a part of the gene,
It shows that the addition of genes causes creation.

The system designer interacts with the hyper-language processing section 222 having a function of realizing such efficient reuse of objects, thereby generating composite objects required for system construction. , Create a session that models the system to be constructed, using atomic objects, existing compound objects, or new compound objects created by itself. As described above, the object management unit 220 controls the execution process of the session generated in this way.

Next, an automatic programming technique (hereinafter sometimes referred to as a specification process) realized by using the object-oriented data processing system of the present invention having such a configuration will be described.

To briefly explain this automatic programming technique, the object-oriented data processing system adopts a configuration in which the user inputs words related to the specifications of the system to be constructed into the object-oriented data processing system. With the technology that selects the registered objects that will be necessary for system construction from the words and interacts with the user to generate the objects (programs) necessary for system construction from those objects. is there. That is, the user can automatically generate the objects necessary for constructing the system only by using the ordinary words that are extensional names.

To realize this automatic programming technique, it is preferable or necessary to adopt a configuration in which processing is performed for each domain of the system. In other words, the system construction is based on knowledge, and this knowledge is replaced by words that can be understood. Furthermore, this word is used in the domain that the building management system is applicable to the building management system. It has a personality that can be used as a unit. Therefore, in realizing this automatic programming technique, it is preferable and necessary to adopt a configuration in which words are defined for each domain of the system and processing is performed for each domain of the system. At this time, the spec word input by the user has a structure that is a name of the object or a keyword assigned to the name. That is, as shown in FIG. 62, the component attribute file 205
Since the name that identifies the object and the keyword associated with the name are set in the object stored in, the user can enter these names and keywords related to the system specifications in the object-oriented data processing system. Will be thrown in. Here, in the figure, the definition means the metadata of an object (a symbolized version of this is a signature).

The names and keywords managed by the parts attribute file 205 are given by the user who created the object. In order to prevent this setting process from being arbitrary, as shown in FIG. 62, a name file that manages a list of names / keywords and a list of definition terms prepared in a relationship paired with these names / keywords are provided. A definition term file to be managed is provided, and the user is allowed to set the registered data of these files.

FIG. 63 shows the processing flow of this setting processing. That is, as shown in this processing flow, first, the user is made to input the name to be used. Next, refer to the name file to check whether the name has already been registered. If not, enter the definition from the definition term file or name file and search for the one that matches this definition. To do. If the search finds a match, it displays the definition and introduces it to the user. On the other hand, when the name is already registered, the definition associated with the name is displayed and checked.

If there is no definition that matches the definition input by the user, a new name is created with that input definition and registered in the component attribute file 205. On the other hand, if there is a definition that exactly matches the input definition, discard the input name and let the user decide whether to use the registered name or not. If it is required to use the input name, register it as a keyword. . If there is a definition that does not completely match the input definition but partially matches it, it is added as a keyword or registered as a new name.

The object names and definitions set in this way correspond to the adoption of a configuration that realizes automatic programming for each system domain, so that the definition can be freely changed for each system domain. Has been taken. And the fact that words are common in the human world means that the meaning that they have is fixed within the domain, but this fixedness has some differences in definition by humans. However, it is not perfect as can be understood from the fact that most definitions are the same. From this point of view, it is necessary to adopt a configuration in which the names and definitions of the objects thus set can be freely changed as much as possible, for example, to be added.

Regarding the name and definition of the object set in this way, if the name is entered so that the user can input an appropriate specification word,
A support function for displaying the definition associated with it on the display screen and inserting the definition on the display screen is provided.

FIG. 64 shows an embodiment of the overall configuration of the specification process. Next, the specification process will be described in detail according to this embodiment. When the question tool 800 prompts the user to specify the processing target domain by inputting the domain name, the question tool 800 causes the user to input a word (spec word) related to the specifications of the system to be constructed, and activates the term check processing 801. By doing so, the term of the spec word input while referring to the management data of the glossary file / definition file 802 is checked,
The specification word necessary for system construction (specification word conforming to the domain) is set, and the specified specification word is stored in the specification file 803.

The specification word set at this time is the name of the object or the keyword assigned to the name. As described above, when a name is entered, the definition (metadata) associated with it is displayed on the display screen, and when a definition is entered, a support function is provided that displays the name associated with it on the display screen. , The user will input an appropriate spec word while using this support function. Here, question tool 8
For the convenience of the user, 00 may be configured to display a list of spec words on a display screen, and to execute input setting of spec words from a selection response to the display. is there.

Subsequently, a temporary signature creating process 804.
First identifies the name of the object pointed to by the spec word stored in the specification file 803, then identifies the signature of the object with that name as a temporary signature, and then identifies the identified temporary signature as a temporary signature file. 805. FIG. 65 shows a processing flow of this temporary signature creation processing 804.

Next, the temporary agent process 806 evaluates the similarity between the temporary signature stored in the temporary signature file 805 and the signature of the processing target domain stored in the domain-specific signature file 807, and determines the similarity. Are stored in the classification signature file 808 in descending order of similarity.

The domain-specific signature file 807 is used as the part attribute file 205 for each domain.
Manages the signature of the object part stored in the system according to the system, the session, the instance, etc. The temporary agent process 806 uses the management data of the domain-specific signature file 807 to resemble the temporary signature. It searches for the signature of the registered object. From the viewpoint of developing a program, the search processing performed at this time is
It is preferable to give priority to the one having a high degree of compositeness.

The meaning of the execution processing of the temporary agent processing 806 is that the spec word input by the user is not always perfect and may be insufficient. Therefore, the specification input by the user may be insufficient. Sometimes I list up signatures that have a part that matches the provisional signature derived from words. FIG. 66
A processing flow of the temporary agent processing 806 is shown in FIG.

Subsequently, a true signature generation processing 809
Generates a true signature from the signature stored in the classification signature file 808 and stores it in the new signature file 810. Specifically, this true signature generation processing first adopts a configuration in which a list of signatures stored in the classification signature file 808 is displayed on the display screen to the user, and the selection for the display is performed. By setting the signature to be processed from the response, and then by interacting with the user, select the gene information (which describes the binding relationship between objects) of the set signature to be processed and move it if necessary. It will be done by doing.

That is, since the signature set as the processing target has the gene information which the provisional signature does not have, the true signature is obtained by executing the selection processing of this portion and the movement processing of this portion. Is generated. At this time, as shown in FIG. 67, the processing is performed by performing a gene operation such that a variable possessed by an object is regarded as a constant, or a constant is regarded as a variable to generate an inverse superclass or an inverse subclass. After changing the target signature itself,
In some cases, selective transfer processing of genetic information is performed. Fig. 68
A processing flow of the true signature generation processing 809 is shown in FIG.

Subsequently, the compatibility check processing 811 reads the signature generated by the true signature generation processing 809 from the new signature file 810, identifies a plurality of objects pointed to by this signature, and performs compatibility matching of those objects. Then, a new object is created, and the signature of the object is stored in the new signature file 810. The compatibility matching performed at this time is performed by the method described in FIGS. 45 to 52.

Subsequently, the temporary operation debugging process 812 starts from the new signature file 810 to the compatibility checking process 81.
When you read the signature generated by 1 and try to operate the object pointed by this read signature, check whether it works as a valid object, and when you decide that it works as a valid object, Component attribute file 205 by determining that the program is necessary for the system
Register with. In other words, even if the objects are compatible with each other, it is not known whether or not the objects can be effectively operated, so that the objects are naturally selected after being temporarily operated.

In the specification process of the embodiment shown in FIG. 64 having such a structure, the files created by the respective processes are independent, so that the sequence of these respective processes can be freely determined as shown in FIG. It can be made more practical by configuring it to have a function.

Thus, in the embodiment of the spec processing shown in FIG. 64, the user inputs words relating to the spec of the system to be constructed into the question tool 800,
True signature generation process 8 that operates in synchronization with this input
In response to the request from 09, a selection transfer process of the genetic information of the signature is executed, and the compatibility of the objects is executed in response to the request from the compatibility check process 811 which operates in conjunction with this selection transfer process. By doing so, it becomes possible to generate the program (object) required for building the system.

FIG. 70 shows a schematic processing flow of the interactive processing executed in this specification processing. That is, the question tool 800 requests the user to input the system name when the user requests the menu by designating the domain name,
In response to this, when the system name is input, the user is requested to input the general function of the system. When the general function is input in response to this, the detailed processing function of the user is input. Is requested to be input by the name (keyword), and in response thereto, when the word of the name (keyword) is input, the specification processing body is activated.

FIG. 71 shows a functional configuration of this specification processing. In the figure, the same components as those described in FIG. 64 are denoted by the same symbols. A point to be noted in this functional configuration is that the question tool 800 inputs and sets a spec word according to a language dictionary used for each domain, and the provisional signature creation processing 804 creates a provisional signature corresponding to the spec word. On the other hand, the provisional agent processing 806 is not limited to the language dictionary used for each domain, but also evaluates the degree of similarity with a signature not related to the domain. This is because the spec words input by the user cannot be said to be completely qualified, and the language dictionary used for each domain cannot be said to be completely accurate.

[0298]

As described above, according to the present invention,
The user can automatically generate the program (object) required for system construction by simply entering the words related to the specifications of the system to be constructed, and at the same time, the automatic generation can be performed efficiently. It will be realized.

[Brief description of drawings]

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

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

FIG. 3 is a diagram illustrating a modeled state of a company department.

FIG. 4 is a diagram illustrating model abstraction.

FIG. 5 is a diagram illustrating a capsule.

FIG. 6 is an explanatory diagram for modeling and grasping an object.

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

FIG. 8 is a basic configuration diagram of the present invention.

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

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

FIG. 11 is a diagram illustrating a configuration of a terminal station.

FIG. 12 is a diagram showing an example of generation processing of classes and instances in an internal schema.

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

FIG. 14 is an explanatory diagram illustrating a state of creating an instance from a class.

FIG. 15 is an explanatory diagram illustrating clothing of a method.

FIG. 16 is an explanatory diagram of a database configuration.

FIG. 17 is a diagram illustrating a processing mode of handling an object.

FIG. 18 is a configuration diagram for performing object management.

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

FIG. 20 is an explanatory diagram for executing processing.

FIG. 21 is an explanatory diagram illustrating a mode in which a causal relationship is incorporated in executing a session.

FIG. 22 is a diagram illustrating the relationship between the existence of a class and the execution of processing by an instance.

FIG. 23 is a diagram illustrating a mode in which a causal relationship is checked in executing a session.

FIG. 24 is a diagram illustrating a hierarchical structure of an object management unit.

FIG. 25 is a diagram illustrating a mechanism of an object management unit.

FIG. 26 is an explanatory diagram conceptually showing the process of extracting knowledge data.

FIG. 27 is a diagram for explaining an object-oriented design aspect that exists at the bottom of the present invention.

[Fig. 28] Fig. 28 is a diagram illustrating a manner of using an object.

FIG. 29 is a diagram showing a manner of creating an object component based on specification orientation.

FIG. 30 is an explanatory diagram of a technique required for forming a super component.

FIG. 31 is an explanatory diagram of a device for realizing componentization.

FIG. 32 is an explanatory diagram of giving independence to an atom object.

FIG. 33 is an explanatory diagram for giving orthogonality to an atom object.

FIG. 34 is an explanatory diagram of giving normality to an atom object.

[Fig. 35] Fig. 35 is an explanatory diagram for giving abstraction to an atomic object.

FIG. 36 is an explanatory diagram of giving a series logic property to an atom object.

[Fig. 37] Fig. 37 is a diagram for describing abstraction of a composite object.

[Fig. 38] Fig. 38 is a diagram illustrating types of WHD structures of atom objects.

FIG. 39 is a structural diagram of a compound object.

FIG. 40 is a diagram illustrating an example of a control component.

FIG. 41 is a structural diagram of a composite object.

FIG. 42 is a diagram illustrating a case where a command link process is used.

FIG. 43 is a supplementary explanatory diagram of FIG. 13.

FIG. 44 is a diagram illustrating a combination technique.

FIG. 45 is a diagram illustrating a compatibility diagnosis process.

FIG. 46 is a diagram illustrating a compatibility diagnosis process.

FIG. 47 is an explanatory diagram of an instance / session / subsystem.

FIG. 48 is a processing flow executed by a hyper language processing unit.

FIG. 49 is an explanatory diagram of screen driven control.

FIG. 50 is a diagram for explaining automation of compatibility diagnosis processing.

FIG. 51 is a processing flow executed when combining objects.

FIG. 52 is a processing flow executed when combining objects.

FIG. 53 is a diagram illustrating a self-PR technique.

FIG. 54 is a schematic explanatory diagram of a self-PR function according to the present invention.

FIG. 55 is an explanatory diagram of a clothing function of an object.

FIG. 56: Part attribute file creation and P for self PR
It is a figure explaining the structure of R processing.

FIG. 57 is a flowchart at the time of program registration by the self-PR function.

[Fig. 58] Fig. 58 is a configuration diagram of functional blocks for self-PR.

[Fig. 59] Fig. 59 is an operational flowchart for creating a program using the self-PR function.

FIG. 60 is a diagram illustrating a reverse link technique.

FIG. 61 is an explanatory diagram of a gene manipulation process.

FIG. 62 is an explanatory diagram of a name / keyword registration process.

FIG. 63 is an explanatory diagram of a name / keyword registration process.

FIG. 64 is an example of the overall configuration of the specification process.

[Fig. 65] Fig. 65 is a process explanatory diagram of a temporary signature creation process.

FIG. 66 is a process explanatory diagram of a temporary agent process.

FIG. 67 is a process explanatory diagram of true signature generation processing.

[Fig. 68] Fig. 68 is a process explanatory diagram of a true signature generation process.

FIG. 69 is an explanatory diagram of spec processing.

FIG. 70 is an interactive processing flow executed in the specification processing.

FIG. 71 is a functional configuration diagram of spec processing.

[Explanation of symbols]

 DESCRIPTION OF SYMBOLS 1 Object-oriented data processing system 10 Questioning means 11 First specifying means 12 Second specifying means 13 Third specifying means 14 Creating means 15 Generating means 20 Compatibility executing means 21 Managing means 21 30 Rule managing means 31 Structured executing means 32 generation means 40 display control means 41 combination execution means

 ─────────────────────────────────────────────────── ─── Continuation of front page (72) Inventor Masanobu Toyoda 1015 Kamiodanaka, Nakahara-ku, Kawasaki City, Kanagawa Prefecture, Fujitsu Limited (72) Inventor Takeshi Adachi 1015, Kamedotachu, Nakahara-ku, Kawasaki, Kanagawa Prefecture, Fujitsu Limited ( 72) Inventor Naomi Ichikawa 1015 Kamiodanaka, Nakahara-ku, Kawasaki City, Kanagawa Prefecture, Fujitsu Limited

Claims (19)

[Claims] 1. An object-oriented data processing system, 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 processing, Grasping the world as an object model, associating the real world with an extensional comprehension and a comprehension, placing the comprehension in an information-hiding area, and identifying the comprehension, iD information is, so to speak, an extensional comprehension Correspondingly configured, using the extensional name, the real world is represented by a static world, a dynamic world, and a causal world that compose the world of the object. , As a static model, give a system mechanism by using a class and / or a composite class, and for the dynamic world, as a dynamic model, And / or a session corresponding to the movement of the dynamic model is given by using an instance of the composite class, and a causal relationship generated from the static model and the dynamic model is given as information in the static model. And a questioning means (10) for executing the input setting process of one or more spec words for the system to be constructed
And a first specifying means (11) for specifying an identification name of an object indicated by the spec word set by the inquiry means (10).
And a second specifying means (12) for specifying a signature indicating the meaning of the object, which is data held by the object indicated by the identification name specified by the first specifying means (11), and the second specifying means. By evaluating the similarity between the signature specified by the specifying means (12) and the signature of another object, the third specifying means (13) for specifying the signature showing the similarity between the specified signature and ,
Create a new object by setting the signature to be processed from the signatures specified by the third specifying means (13), selecting the signature element of the signature to be processed, and moving as necessary. And a generating means (15) for generating an object required for system construction by combining the objects generated by the generating means (14) while matching them with each other. Object oriented data processing system. 2. The object-oriented data processing system according to claim 1, wherein the identification name of the object is used as a search key so that the semantic information displayed by the signature of the object can be referred to and the semantic information is used as the search key. And then
An object-oriented data processing system characterized by being configured so that the identification name of an object can be referred to. 3. The object-oriented data processing system according to claim 1, wherein the identification name of the object and the signature of the object assigned to the identification name can be freely defined and changed. Object oriented data processing system. 4. The object-oriented data processing system according to claim 1, wherein specification words are defined for each domain of the system, and processing is executed for each domain to which the system to be constructed belongs. An object-oriented data processing system characterized by: 5. The object-oriented data processing system according to any one of claims 1 to 4, wherein the inquiry means (10) is configured to display a list of specification words on a display screen, and selects from the response to the display. An object-oriented data processing system characterized by processing to execute specification setting processing of spec words. 6. The object-oriented data processing system according to claim 1, wherein one or more keywords are assigned to the identification name of the object, and the first specifying means (11) is the keyword. An object-oriented data processing system characterized by processing so as to specify an identification name while considering 7. The object-oriented data processing system according to any one of claims 1 to 6, wherein the third specifying means (13) performs processing for executing a specification process of a signature indicating similarity while giving priority to a large object. Is an object-oriented data processing system. 8. The object-oriented data processing system according to claim 1, wherein the creating means (14) displays on the display screen a list of objects having the signature specified by the third specifying means (13). An object-oriented data processing system, characterized in that the processing is performed so as to set a signature to be processed from a selection response to the display. 9. The object-oriented data processing system according to any one of claims 1 to 8, wherein the creating means (14) operates a signature to be processed while interacting with a display screen, thereby creating a signature different from the signature. An object-oriented data processing system characterized by performing processing so as to set as a processing target. 10. The object-oriented data processing system according to claim 1, wherein the creating means (14) interacts with a display screen,
An object-oriented data processing system characterized by performing processing for selecting and moving signature elements of a signature to be processed. 11. The object-oriented data processing system according to claim 1, wherein the files created by each means are independent of each other,
An object-oriented data processing system characterized in that the processing order of each means can be freely determined. 12. An object-oriented data processing system that 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 processing, Grasping the world as an object model, associating the real world with an extensional comprehension and a comprehension, placing the comprehension in an information-hiding area, and identifying the comprehension, iD information is, so to speak, an extensional comprehension. Correspondingly configured, using the extensional name, the real world is represented by a static world, a dynamic world, and a causal world that compose the world of the object. , As a static model, a system mechanism is given by using a class and / or a composite class. And / or a composite class instance is used to provide a session corresponding to the movement of the dynamic model, and the causal relationship generated from the static model and the dynamic model is provided as information in the static model. When multiple objects whose sequence structure is specified are specified, by interacting with the display screen, the compatibility of the object is executed and other objects that have a causal relationship with the object are executed. If there is, the compatibility execution means (20) for executing the combining process between the two objects and the compatibility execution means while distinguishing the compatibility match / mismatch disagreement.
(20) is provided with management means (21) for managing sequence information between objects and causal relationship information obtained as a result of compatibility as compatibility result information, wherein the compatibility execution means (20) is a management means prior to execution of processing. The past execution result is referred to according to the management data of (21), the process is executed when it is determined that the sequence structure of the specified object is not registered, and the compatibility result information of the execution result is registered in the management means (21). An object-oriented data processing system characterized by processing as it goes. 13. The object-oriented data processing system according to claim 12, wherein the compatibility executing means (20) manages means (21) prior to executing the processing.
The past execution result is referred to according to the management data of the specified object, and when determining the compatibility registration of the sequence structure of the specified object, the connection process with the causal relationship object is executed, and the compatibility result information of the execution result is managed by the management means. (twenty one)
An object-oriented data processing system characterized by processing to be registered in. 14. An object-oriented data processing system that 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 processing, Grasping the world as an object model, associating the real world with an extensional comprehension and a comprehension, placing the comprehension in an information-hiding area, and identifying the comprehension, iD information is, so to speak, an extensional comprehension. Correspondingly configured, using the extensional name, the real world is represented by a static world, a dynamic world, and a causal world that compose the world of the object. , As a static model, a system mechanism is given by using a class and / or a composite class. And / or a composite class instance is used to provide a session corresponding to the movement of the dynamic model, and the causal relationship generated from the static model and the dynamic model is provided as information in the static model. And the rule management means (30) that manages the compatibility rule that holds between objects, and when multiple objects whose sequence structure is not specified are specified, By using the structured execution means (31) that gives the sequence structure and the management data of the rule management means (30), the compatibility of the objects that are sequence structured by the structured execution means (31) is evaluated, and the object When it is determined that is a compatible object, Generating means for generating the object as a valid object giving sex (3
2) An object-oriented data processing system characterized by comprising: 15. An object-oriented data processing system, 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 processing, Grasping the world as an object model, associating the real world with an extensional comprehension and a comprehension, placing the comprehension in an information-hiding area, and identifying the comprehension, iD information is, so to speak, an extensional comprehension. Correspondingly configured, using the extensional name, the real world is represented by a static world, a dynamic world, and a causal world that compose the world of the object. , As a static model, a system mechanism is given by using a class and / or a composite class. And / or a composite class instance is used to provide a session corresponding to the movement of the dynamic model, and the causal relationship generated from the static model and the dynamic model is provided as information in the static model. When multiple objects to be combined are specified, the objects are displayed in the logo format on the display screen, and the attribute information of the objects is displayed in association with the logo display. By interacting with the display control means (40) to be displayed on the screen and the display screen, the compatibility matching process between the objects of the logo display and the value setting process of the attribute information are executed, and the An object-oriented data processing system characterized by comprising a combining execution means (41) for executing a combining process. Beam. 16. The object-oriented data processing system according to claim 15, wherein the merging execution means (41) performs processing so as to display a merging relationship between the objects on a display screen by using a line drawing. Oriented data processing system. 17. The object-oriented data processing system according to claim 15 or 16, wherein when there is a combination instruction that does not match the compatibility, the combination execution means (41) processes so as to reject the combination instruction. Object oriented data processing system. 18. The object-oriented data processing system according to claim 15, wherein the combining execution means (41) interacts with the display screen when another object having a causal relationship with the designated object exists. An object-oriented data processing system characterized by processing to execute a combining process between both objects. 19. The object-oriented data processing system according to claim 15, wherein when the logo form of the display screen is changed, the signature for displaying the meaning of the object is changed corresponding to the change. An object-oriented data processing system characterized by the fact that objects are also modified.