JPH07114464A - Object-oriented data processing system - Google Patents

Abstract

PURPOSE:To utilize an object component effectively by adopting totally attribute information of an object as meta-data and real data and managing organically and definitely the meta-data and real data. CONSTITUTION:A component attribute file 205 storing an object component stores meta-data and real data of an object specified by an object command. When a new object is generated, a commandlink processing section 204 sets an object command corresponding to a call name of the object and allocates a storage location of the meta-data and real data to generate a command link table. An object management section 220 reads a generated session and starts the object while taking restriction of a casual sequence into account according to a sequence of the session. A direct object processing expansion processing 215 compiles the session confirmed of normal operation to convert the result into execution processing data.

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, by constructing a structure that comprehensively and organically manages the attributes of objects, an object that enables effective use of object parts can be realized. 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.

That is, in the conventional system development, the system designer has a procedure in which the work contents and requirements of the user are compiled as a specification document, and the programmer starts to create a program based on the specification document.

At this time, the system designer is faced with various demand offensives from the user, and on the other hand, he is faced with the difficulty of the program to realize the demand and the troublesomeness, and is forced to take great pains.

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, when designing a system with a current procedural program, the following five problems in software creation are major causes that hinder the efficiency of the system design. (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.), layout on screen, size, color scheme, blink processing There are many considerations from the viewpoint of operability and legibility. The number of screens can easily reach hundreds, which is a very troublesome task.

[0007]

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 simply and faithfully replace the real world with the 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 extensional nouns and the world of information-hiding 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 composed of extensional nominatives are so-called "composite worlds by nominatives" in which nominatives are associated with each other by pointers or messages. Has become.

[0012] In general, 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.
It is based on a completely different idea from the conventional software technology, and in order to realize this, it is necessary to construct a structure that comprehensively and organically manages the attributes of objects.

However, in the related art, as will be described with reference to FIG. 16, although the structure for managing the actual data (user data) and the metadata describing the property of the actual data may be adopted, they are unified. It does not adopt a configuration that manages. Further, the metadata to be managed is limited to management information such as who created it at any time, which is insufficient to realize the construction of the object-oriented data processing system newly proposed by the present inventors.

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. A new object that enables effective use of object parts by constructing a structure that comprehensively and organically manages the attributes of an object when the structure given as information in a static model is adopted. The purpose is to provide a directional data 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.

FIG. 1 shows the basic configuration of the object-oriented data processing system of the present invention having such a configuration. In the figure, 204 is a command link processing unit, 205 is a component attribute file, 205 'is an execution processing data file, 212 is a dynamic object processing unit, 21
Reference numeral 5 is a direct object processing development processing, 220 is an object management unit, 221 is a display, and 222 is a hyper-language processing unit.

The component attribute file 205 stores object components, and stores actual data and metadata (which describes the property of the object) of the object specified by the object command. Unlike in the past, the actual data and the metadata are integrally accessed instead of being accessed individually.

The command / link processing unit 204 is also called a directory processing unit. When one new object is created, the command / link processing unit 204 sets an object command corresponding to the designated name of the object, and sets the actual data or meta data. Allocate the data storage location and create the command link table. At this time, the type of the object is determined and the size is determined. And the command link
Use a table to enable input / output of a combination of actual data and metadata.

The hyper-language processing unit 222 has a function of generating a new composite object from an atomic object (a basic unit of an object) or an existing composite object (a combination of a plurality of objects), and the function of the object. A function to generate metadata that describes properties, a function to generate a signature by symbolizing the metadata, and the metadata
It has a function of outputting as R information and a function of manipulating gene information (which describes the structure of an object) of a signature.

The object management unit 220 controls the execution process of the object. To explain the execution control process of the session, the generated session is read and the causal constraint is considered according to the sequence of the session. While doing so, it will process so as to activate the object.

Direct object processing expansion processing 2
Reference numeral 15 compiles a session confirmed to operate normally and converts it into execution processing data. This is the object management unit 2 when the session is operated as it is.
The reason is that it is necessary to exchange a lot with 20 and the processing speed is slow, so that it is converted into execution processing data for actual operation.

The actual process data file 205 'stores the execution process data generated by the direct object process expansion process 215. The dynamic object processing unit 212 controls simulation, test, and production operation, and controls the execution of execution processing data stored in the actual processing data file 205 ′ if it is explained in production operation.

[0025]

In order to construct the object-oriented data processing system of the present invention, in the present invention, as the metadata of the object, management data describing the management information of the object (the creator of the object, the creation date, the authorized person, etc. Display), semantic data that describes the meaning of the object (displays the name and keywords of the object, domain classification, processing flow, specifications, etc.) and gene data that describes the structure of the object (configuration object part name and its connection Display), and an internal iD that describes information about the substance of the object (O-iD indicating actual data, work area size, necessary library, etc.),
Eno describing the history of evolutionary degeneration of objects
A configuration for managing the version data and the signature for encoding the metadata excluding the eno version data (the O-iD can be excluded or the eno version data can be included) is also managed.

That is, in the conventional data processing system, only the management information is taken as the metadata that describes the property of the actual data, and the metadata and the actual data are managed according to different management systems. On the other hand, the object-oriented data processing system of the present invention has a configuration in which attribute information of objects is comprehensively taken as metadata and these metadata and actual data are centrally and organically managed. is there.

Most of this metadata is automatically generated according to the processing of the hyper-language processing unit 222 and registered in the component attribute file 205, and what kind of object is used when generating a composite object. It is output as self-PR information to inform the user of whether or not it is used as operation target data at the time of gene operation, or used for searching for objects having similar extensional names.

Thus, by using the present invention,
The object-oriented data processing system for constructing the object world (virtual human world) by the extensional proposition proposed by the present inventors can be realized, and the object parts can be effectively used.

[0029]

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 which 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 required. 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 under the relationship of “worker / machine” within the framework of “work unit”. Related to "machine".

The "team" and the "machine" are related under the relation "machine / workplace", and the "worker" and the "machine" are again related under the relation "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 “relationship”, 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.
It can be treated as an object one by one.
Considering a collection such as the method a and the data I shown in FIG. 4, consider encapsulation as shown in FIG. 5 (A). A hole formed above the capsule in FIG. 5 (A) indicates that a message can be exchanged.
If the upper hole of the capsule shown in FIG. 5A is assumed to be blocked, it corresponds to data IV which is a collection such as method a and data I shown in FIG. The data is shown in FIG.
It is shown at the left end of (B). When a method M is added to the leftmost data D in FIG. 5B to obtain a compound object, the data becomes the data shown in the center of FIG. When the obtained object is obtained, it becomes the one shown at the right end of FIG. The composite thus formed corresponds to FIG. 5 (C).

The mode in which the compounding is performed is as shown in FIG.
It is not limited to. For example, at the leftmost end of Fig. 5 (C)
In the object shown, the data D is the method and the data.
When replaced by an object consisting of
It is the second one from the left end. In this case, the illustration
Method M₁And data D₁Between the message
Thing is required, and it is shown as the third from the left end of Fig. 5 (C).
Method M like a thing ₁Is an object.
As a result, the objects A and
Object B and object A and object
There is a message passing between B and
It will have a structure.

Further, assuming that the method M in the illustrated object B is an object B ₁ and the data D in the object B is an object B ₂ , the method shown in 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, III are larger objects IV, V, 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 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 configuration 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 parts for generating a class, and 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 portion 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 relation 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 which is a constituent element 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 noun. This extensional name, that is, an extensional name containing a certain meaning, is used to simulate the real world. That 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 relationship between the processing target units is designed. Formed by. Then, a constraint due to a causal relationship is given between the static model and the dynamic model.

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 by performing compilation processing on 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 in the form of the above-mentioned atomic object, the above-mentioned state of the capsule object, the above-mentioned state of the event object, the above-mentioned 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 serves as a unit that exhibits a behavior for executing a process having a 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 the 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 which have been normally operated in the temporary operation mode 216, the processing speed is slow as it is because it requires a lot of communication with the object management unit (see FIG. 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 the 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.

FIG. 11 (temporary operation support) 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 "part display" function using the display 221 includes (i) a table of contents for outputting the name and comment of the metadata of the object part, and (ii) a schema and attributes indicating the contents of the object part. Display of,
(Iii) There are indications of class attributes and instance constants.

In addition, the "component combination" function by the hyper language processing unit 222, that is, in order to combine object components to obtain a larger composite object component, an attribute addition / modification / deletion function is prepared for class creation. 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, the method is linked to 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 section 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).

"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 part does not exist in the own terminal station 101, has no attribute, or has no schema, the other end station will receive a message 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 class and instance generation processing 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 is a conceptual representation of the information hierarchy 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 conceptual schema 300 described above. 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 is pop-up data, which is extracted and written as instance data in the instance schema 316 from the pop-up data.

For example, when trying 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 a class related to a passenger car is to be generated, and also inputs the various kinds of method names that are thought of to the metaclass method 311.

Correspondingly, 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 combine and use methods as appropriate while generating a desired class, changing a method used in the class, and changing instance data.

A method for performing the desired data processing is formed, a plurality of methods are combined to form a class, and a plurality of classes are combined as necessary to form a composite class. Or has been. 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.

Also, 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.

Corresponding to the formation of the above class and the formation of the instance schema, the static world has a 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 purpose is designated. 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 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 starts the instance (incorporates 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.

In creating an instance, the instance data used in each method is set on the instance schema 316. Then, the content of the set instance schema is linked with the method ID on the class schema 312. This causes the method in the associated class to be executed using the contents of the instance schema 316. A specific processing program (instance) can be executed. The execution is performed by the object management unit 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 the state where the class, that is, the instance data is still described in the form of a variable, the one completed by designating the specific instance data corresponding to the variable is specified. It is a processing program for performing the processing of. The processing program in which the variable is set to 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 view 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 a 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 drawing) or a complement (C in the drawing) that indicates the operation of the method is described together with the method itself (M in the drawing) 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 and death", "open / closed", "Input", and
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 is 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.

Further, conventionally, with respect to each user data under the management of the above-mentioned DBMS, a meta data describing a 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, in order to explain what role each individual user data has, Meta data is created. Then, a meta data database 211 that stores the meta data collectively is used, and a data dictionary and directory system (DD / DS) is used to centrally manage the meta data database 211. ) Is provided.

In the present invention, the meta data and the user data shown in FIG. 16 are collectively grasped as the 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 atomic 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 form the above-mentioned 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 component generally has a sufficiently large amount of information, and it is desired to give the object component a name for briefly explaining the content of the object component.

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 designation 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 an existing object part, 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 the individual objects, and performing processing that matches 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 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 so that the processing target can be freely designed as appropriate, and can be easily processed for 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 indicated in the static world 410, and a composite class obtained by compositing the class 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 illustrated case, A, B, C, D, E, F, G, K, L are defined as the class 302 ′ for the processing of the processing target.
Is taken in, (i) the class G and the class A are in the “is-a” relationship with the class E, and (ii) the class D is the “is-a” relationship with the class A, (iii) Class B has an "is-a" relationship with Class F, and (iv)
Class D and class K are "part-" for class B
It is shown that the relationship is "of", and (v) the class K and the class L are in the relationship of "part-of" with respect to the class C. Actually, it is described in the static world. The class 302 ′ is assigned with an ID sufficient to point to the class 302, the method 313, ... Which exist in the procedure world 403.

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.

For example, if a 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 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 using the class A corresponding to the formula, but 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" with respect to 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.

Session I and session II are executed under the dynamic model 421. 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 execution of instance u in session II as a result of executing instance u in session I, instance u of 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 execution of processing by an 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.

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 required by associating template creation, class creation, instance creation, and session creation with each other. , 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 of the above-mentioned sessions, 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 the session is assigned as an example, the sequence reading mechanism 224 reads each of the 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 first layer obv 220-1 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 causes 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 (a sequence not directly related to the time order) in the static model or a dynamic sequence in the dynamic model (a sequence directly related to the time order) is modified. 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 a terminal node other than itself. It can be regarded as equivalent to data.

As a method of linking the above data, there are an internal link 454 in the same knowledge data, an internal link 455 to latent 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 the user :: A problem corresponding to the request is described, and a scenario for summarizing specifications is created.

Next, an analysis is performed, and what kind of data is needed, what methods are needed 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 is created for related events, 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.

[0193] The user's request is dealt with based on the instance obtained as described above, but the classes, composite classes and instances obtained during this period are functional models 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 the object parts in the left half of 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.

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.

As is apparent from the above description, 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 a system. 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 atom object A, an instance b created for the atom object B, and an instance c created for the atom 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, the arguments can be automatically adjusted so that they can be combined regardless of any combination. 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 atomic 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 an 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.

Atomic 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.

Atom objects are all 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 condition of this atomic object is 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 was introduced to give independence to the object, but in order to realize this independence, the command / link processing unit 204 is also greatly involved. 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 of 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.

In order 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.

The hyper language processing unit 222 preferably implements this combination technique in the screen language. For example, if a system designer selects a table of contents that is required for combination and displays it as a logo, the parts are displayed as a logo and the input data, output data, and HOW parameters are associated with the logo. It is possible to display and set the order mode (substantial value can be set when creating an instance) or message mode (which becomes a parameter that determines the sequence when creating a session) for those data, and between the parts It is realized by displaying the connection of the lines.

Further, it is preferable that the hyper language processing section 222 implements the automation processing of this combination technique. This automated processing has, for example, a configuration in which the result of the compatibility diagnosis performed with the system designer in the past is stored in a file. As shown in FIG. 47, for example, an object a, an object b, and a c Specify objects and as the structure class, and select "a → b →
If you want to create a sequence class in the order of "c", you can refer to this file and automatically determine whether the combination is possible or not. It will be possible.

Next, the self-PR technique prepared for realizing the super-partization of the object parts will be described. As shown in FIG. 48A, 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. 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. 49 to 54. FIG. 49 is a schematic explanatory diagram of the self-PR function according to the present invention.

When the operator issues a usage request to the parts group from the display, each part will self-promote itself by the self-PR function. 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 instructing 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 drawn out 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. 50 is an explanatory diagram of the clothing function of an object. As shown in FIG. 50, the clothing function of an object is a function of converting it into an object by passing a program (which may be a normally created program). When made into an object, a list of buffers used by the programs used therein (a in FIG. 50) and a comment list (b in FIG. 50) 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 process (c in FIG. 50). 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. 50),
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.

Semantic data is manually input because it is difficult to automate it because parts are grasped by an 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. 51 is a diagram showing the structure 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. 51 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 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 is almost 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 the 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: Structural 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 process 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. 52 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 buffer in the program or the buffer is taken out, and it is put together in a structure, and at the same time, only the comments are put out in the structure, and further metadata and the like are input (S1 in FIG. 52). 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. 53 is a block diagram of functional blocks for self PR. Functions b, c and d in FIG. 53 correspond to the process S1 of the flow shown in FIG. In FIG. 53, for the program a to be registered, the function b for extracting the used buffer, the function c for extracting the comment, and the function c for extracting the comment and the function of inputting metadata, semantic data and flow, and source 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. 51 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. 54 is an operation flow chart for creating a program using the self PR function. In FIG. 54, reference numeral 510 represents 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.

The process will be described. When an operator makes a usage request for a part (object) (S in FIG. 54).
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 content is displayed and it is judged whether the content is a part (object) (at step S10). If it is a part, data such as a variable corresponding to the part is input (at 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. 55 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. 56 illustrates this genetic manipulation process. FIG. 56 (A) shows a hierarchical structure of object parts by genetic manipulation. One superclass is just one NULL, and one superclass is another superclass. It is shown that the object parts are layered by the genetic manipulation such that "." Further, in FIG. 56 (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, and at the same time generates the complex objects necessary for constructing the system. , 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.

FIG. 57 shows the overall structure of the object processing described above. The user data object in the figure corresponds to the above-mentioned hyper language processing unit 222,
An object that creates a class schema, instance schema, sequence data, etc. The metadata object is an object that executes metadata processing. Given a specification word about the system to be constructed, the specification object first specifies the object that the specification word points to, thereby specifying the signature associated with that specification word, and then specifying It is an object that executes a specification process of automatically identifying a system-related object by searching for a signature similar to the signature and combining the specified objects to automatically generate a program required for the system. The command link object corresponds to the command / link processing unit 204 described above and is an object that links the actual data (user data) and the metadata.

The retrieval object is the component attribute file 2
It is an object to retrieve 05. The screen object is an object that supports a human interface. The expansion object is the direct
This is an object corresponding to the object processing expansion processing 215 and compiling a system or session confirmed to operate normally to generate a direct object. The dynamic object corresponds to the dynamic object processing unit 212 described above and is an object that switches processing modes such as temporary processing and direct processing. The three-layer communication object is an object that controls communication control processing.

Next, the metadata that describes the property of the object will be described in detail. As shown in FIG. 58, this metadata is registered in the component attribute file 205, and mainly the hyper language processing unit 222.
Most of them are automatically created according to the processing of (user data processing). This part attribute file 205
Also serves as backup data for backup and has all the main data that can be restored to the workstation. Further, the metadata is configured to be forcibly rewritable at the request of the user, and the person who is permitted to rewrite the information can be freely set.

FIG. 59 shows an example of the metadata registered in the component attribute file 205. As shown in this figure, what is included in the metadata is roughly divided into old DD / DS data, semantic data, gene data, internal iD, signature, and enoversion data.

The old DD / DS data is named because it is equivalent to the data managed in the conventional database, and the creator of the object, the creation date of the object, the object Describe the person who modified the object, the modification date of the object, the name of the workstation used, and the permission level for modifying the metadata.

Semantic data is prepared mainly for self-PR, and is a domain classification set by the specification processing by the above-mentioned specification object (in the specification processing, the specification word is effective in the domain. Object is generated in units of domains from), object parts types (atomic parts, class parts, instance parts, session parts, causal parts, etc.), object names, and object Keywords assigned to names, comments / specifications about objects (things that express the names and connection relationships of constituent objects in schema terms), object display logos, processing flows executed by objects (in the logo form) Expression), the domain of the data of the object, Describing the parts attributes and the like of the object.

Gene data is mainly used in the specification processing by the specification object described above,
The structure of an object is displayed by describing the component names of the object and their connections.

The internal iD is a data group relating to directory data, and describes an O-iD indicating actual data, an address / size, a work area size, a source address, a necessary file / library, etc.

The signature is data obtained by symbolically compressing these old DD / DS data, semantic data, gene data, and internal iD. Among the signatures generated in this way, old DD / DS data, semantic data, internal iD
The signature about is regarded as a mental signature having a management meaning, whereas the signature about genetic data is regarded as a structural signature displaying structural information. Note that the internal iD may be removed to generate the signature,
A signature may be generated by adding the eno version data described below.

Eno version data describes the history of evolutionary degeneration of an object, and is indicated by a change mode and an eno version number. Once an object is created, it changes with the passage of time, such as a class object creating an instance object, and also changes according to the processing of the distribution destination. Eno version data describes the evolutionary degeneration history of this object.

FIG. 60 shows a path for creating this metadata. The metadata is created as shown in FIG. 60 or through the creation route of
Of these, it is automatically created when passing through the creation route of, and created by manual input by the user when passing through the creation route of.

The metadata passing through the creation route is automatically created by activating the hyper-language processing section 222. For example, the parts type, the eno / version number / mode, the metadata are automatically created. There are comments, processing flow, etc. The metadata that goes through the creation route of
It is created automatically as management information. For example, creation date, creator, workstation name, modifier,
There is a correction name etc.

The metadata passing through the creation route of is created automatically from other processing.
Domain classification, name, keyword, signature, etc. set by the specification process (processing by the above-mentioned specification object), O-iD, address / size, work set by the command link processing (processing by the above-mentioned command link object) Area size,
Source address etc. The metadata passing through the creation route of is created by the user's manual input, and includes, for example, name, keyword, eno version mode, comment, domain, display icon, permission level, atom object There is a flow number etc.

FIG. 61 shows a form of creating each metadata described in FIG. Here, in the figure, the ∘ mark indicates that it is created automatically, and the Δ mark indicates that it is created automatically.

As shown in this figure, with respect to the old DD / DS data and the semantic data, some manually input data remains. This is because it is necessary to manually input whether the current process is just use of the part, creation, or modification, and a comment that is automatically set (a comment that is self-promoted as a specification) , There is a comment to be entered in the program) and the supplementary comment must be manually input, and the domain of the data / unregistered name / keyword that you noticed are manually input. There is a reason for that.

Next, the automatic generation processing of the comment / name / keyword which constitutes the metadata will be described. The comments that make up the metadata are the object's own PR.
It is important data that is output for use in FIG. 62 illustrates how to make a comment for each component. These are to be input when the user data is created by preventing the process from proceeding unless the user inputs it. It may be a name or actual data. A plausible comment will be created by expressing the flow chart of each part in appropriate words. By taking the descriptive expression "...
It will be edited into something that is semantically easy to understand. However, to introduce the system name, the session names that operate in parallel are listed in a bulleted list (starting conditions can also be added).

Specifically, as shown in FIG. 63, when an instance is generated, a comment is automatically generated from the class that is the generation source, and when a session is generated, a comment is generated from the instance that is the generation source. Is automatically generated,
When the system is created, the comment will be automatically created from the session from which it was created.

The attribute name of the method attribute composing the comment of the class name is input by the user who creates a class by user data processing, in addition to the name of the method registered in the clothing function of the object. Is. This class has a special schema method as a method because it can be used for anything. It can be said that this is to supplement the description of the class or instance. However, in the case where most parts are data parts like a database system, only this schema method describes the data parts. Therefore, when this schema method is requested, its attribute name can be changed even when creating an instance.

Further, a manual comment input mode is prepared for a user who thinks that the automatically created comment is not sufficient. In this manual input mode, comment grammar can be constructed. This comment grammar allows you to rearrange existing comment schemas and set your own manually entered comments wherever you like.

Next, the name / keyword automatic generation processing will be described. As shown in FIG. 64, a name identifying the object and a keyword associated with the name are set in the object stored in the component attribute file 205. The definition in the figure means the metadata of the object.

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

FIG. 65 shows a 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 the 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 name is used as a primary key, while the keyword is used as a subordinate key.

The dictionary of the name / definition of this object is created for each domain. That is, system construction is based on knowledge, and this knowledge is replaced by words that can be understood.
Since this word has a character that can be used in units of domains such that a building management system can be used in a building management system, this dictionary is created for each domain.

Next, returning to the discussion, consider the semantic data of the class object when the class object was created. The atomic object has an abstraction, and the data part is the majority and the processing part is few.
That is, most are made of buffers. On the other hand, ordinary programs are mostly processing programs and have only a few parameters. With this,
You can't see what the program does by looking at only the buffer name. However, since most of the atomic object has a buffer part and a small amount of processing part, if most of the buffers are named when trying to use the atomic object in the class object, this is considered to be valid as semantic data of the class. It will be.

Although the metadata item of such metadata has a basic form in all parts, basically, it is increased or decreased by moving the hyper language processing unit 222. Therefore, in the component attribute file 205 storing this metadata, it is necessary to change the meta items, that is, the schema freely, as shown in FIG. Of course, this also needs to be interactively changeable on the screen. The screen display should be handled as an object for each meta item. Of course, Tupple can also be handled as an object.

Next, the usage form of the metadata will be described. FIG. 67 illustrates a usage form of metadata. As shown in this figure, the metadata will be used for parts introduction, parts search, parts management, backup, gene analysis, gene manipulation, and the like. Next, the usage forms of these will be described. (1) Introduction of parts Introduction of parts is the base of self-PR function,
For example, if the user outputs simple semantic data (comment automatically created, etc.) that is the extension content of the metadata after the name, and the user requests even more inclusive content, Comments, flows, constants in flows, other keywords, eno version mode, old DD / DS data, sources, and metadata of inclusive details such as signatures. Done. (2) Searching for Parts As shown in FIG. 68, parts are searched for by name (primary key), by keyword (subordinate key),
There are various searches such as search by semantic data, search for each domain / part, etc. By performing a prescribed search process on the metadata with a part of the metadata as the search key, the information desired by the user is searched You can do it. (3) Component Management Component management is a process of tracking the change history of a component over time using metadata. According to the metadata, the contents of the change at that time, the person who made the change, the reason for the change, etc. can be known. This facilitates failure analysis. (4) Backup Backup is the process of using metadata to restore the system or using metadata to regularly back up other workstations. (5) Gene Analysis Gene analysis is a process of analyzing genes contained in metadata. The genes included in the metadata include the structural signature and the mental signature, as described above.
The structural signatures within this are about methods, which you can use to "method + data = capsule"
Can be restored. Changing the metadata changes the structural signature, and changing the structural signature changes the metadata. The former is a forward link and the latter is a reverse link function. The mental signature is a signature for public relations and management. (6) Gene manipulation Gene manipulation is a function of causing a reverse link by manipulating a signature.

Next, the signature prepared as one of the metadata will be described in detail. The signature is data obtained by symbol-compressing the metadata, for example,
It is generated by allocating a bit to an extensional word and flagging the metadata if the word has that word. FIG. 69 (a) illustrates a signature generation process. As shown in this figure, the signature is
It is created by symbol-compressing the old DD / DS data, the semantic data, the gene data, and the enoversion data that make up the metadata, and the partial signature that is the substantial part of the signature and its part. All signatures are composed of a header that manages the expansion area of the signature and the like. When creating a signature, an internal iD may be added or eno version data may be removed.

As shown in FIG. 69 (b), the signature configured as described above is created when metadata is generated, and added when metadata is added or changed. -It will be changed.

The created signature has the O-iD incorporated in the metadata, and all the signatures also become one soft sensor and are stored by the command link. Preferably, only the internal iD of this part allows the eno version data / signature to be pulled out in the form of a mode with a command link. At this time, it is not necessary to include the signature / eno version data in the metadata.

[0290] The metadata evolves as the object evolves, and the signature changes accordingly. In order to deal with this, as shown in FIG. 70, a signature ((b) in the figure) which is evolved later is added to the signature ((a) in the figure) generated first. Taking the method. This can be thought of as adding unnecessary signatures that are needed while leaving unnecessary signatures. From now on, the signature will need a header. This header is
It has management information such as how many bytes the signature has and what type of metadata it has. This type allows you to see what the structure of the signature that follows is going to be.

According to such a configuration, meaningless data is described in the signature, but this meaningless data is not meaningless in essence, and because of this, there is a specific signature. When extracting signatures that have some relation from, fuzzy search, associative search, and creative search become possible.

Next, the usage pattern of the signature will be described. FIG. 71 shows a usage pattern of the signature. The signature is the media, as shown in this figure.
It will be used for industry judgment, speeding up learning, simple artificial intelligence, parts search and spec-oriented method, association and creation by abstract structure, fuzzy search, simulation, common object model, judgment by conversation, etc. Next, the usage forms of these will be described. (1) Judgment of media and industry Judge the media and industry from the signature. The judgment of the media is made in relation to the data component and the method group accompanying it. The judgment of the type of business is to judge the domain in the specification-oriented manner. (2) Speeding up learning When signatures are sent from other workstations, it is possible to judge from the signatures whether or not the data necessary for the own workstation is available. You will be able to learn at high speed. (3) By linking a simple artificial intelligence signature back, you can compose a comment, see the specification, and see its definition. (4) Parts search and spec-oriented method The roots can be traced back from the signature to the atomic object. In the spec-oriented method, parts are selected by using the reverse link, and new parts are generated by combining the selected parts. (5) Association and creation by abstract structure By using the reverse link by using the structural signature,
You can create associative parts and creative parts. (6) Ambiguous search You can search by using input keywords.
This is a synonym for the definition. If you consider ambiguous as an association, the data (part) that contains the input keyword
It becomes a fuzzy search to bring out. (7) Simulation It is possible to try moving by replacing the structural signature with genetic manipulation. (8) Common Object Model When terminal A sends signature X _A to terminal B,
The process executed when the terminal B does not expand the signature X _A is the common object model. Terminal B having this common object model has signature X
_A signature X _B similar to _A is searched, and a property ΔX _A (= X _A −X _B ) that does not match the two is created, and the knowledge “X _B + ΔX _A ” is obtained, and the signature X _A
I will accept it. It behaves as if humans were learning a foreign language. (9) Judgment by conversation When the signature is changed to substantive data or a name, the signature is connected to the metadata, and thereby the question is answered.

Next, a simple dictionary to be introduced when the present invention is applied to the distributed data processing system will be described. In the present invention, a signature with O-iD is referred to as extensional meaning data (object command). On the other hand, as shown in FIG. 72, in the age of knowledge acquisition, a person greedily tries to know the essence of the knowledge to know the essence of it, but when he enters the era of using it in an outward manner,
You don't have to go deeply into the comprehension, you just need to look up the comprehension and learn about the comprehension. For example, given an integral formula, in the age of knowledge acquisition, we try to know the essential meaning of the integral formula, but when we become accustomed to the innate knowledge, we use only the law of the result of the integral formula. Of.

Correspondingly, when the present invention is applied to the distributed data processing system, as shown in FIG. 73, the detailed dictionary is expanded in the center system, and
A configuration in which a simple dictionary is expanded to each workstation is adopted. In other words, when user data processing, command link processing, eno / version management processing, and spec-oriented processing start, most of the metadata is automatically set as described above, and 90% of comments and specifications are completed. What is done is made. This is the whole picture of the detailed dictionary developed in the center system.

On the other hand, each workstation has a structure in which a simple dictionary for interpreting extensional meaning data is developed. In the case of a program object, this simple dictionary manages, for example, a list of session names for a system name, a list of instance names for a session name, and a list of attribute names + data for an instance name. A class name manages a list of method names and data attribute names, and a method name manages information such as managing a parameter name and a pattern name attached to a method.

In the case of a data object, for example, if there is a schema in O-iD, the O-iD
Only a list of iD names, only sequence names for sequence data, only file names for logging data and time series data, only names for patterns, schema name + taple data for causal relationship taple data, and eno version data It manages information about the attribute name / definition name only, not the definition name. Further, since the mental signature is management information, information not related to the user is not managed, but information about the usage level of parts, other keywords, and a display logo is managed at most.

In accordance with this dictionary structure, a simple dictionary is used when a data processing is executed by transferring an object command composed of a server and a client, which is composed of iD information indicating a comprehension and a signature. The expanding client interprets the object command transferred according to the simple dictionary, and when it needs to obtain the detailed information about the inclusion, it executes the data processing by inquiring to the expanding dictionary server. It is processed as it goes.

As described above, in the object-oriented data processing system of the present invention, as shown in FIG. 74, a divine entity gives a definition to a word, and usually communicates with an exaggerated word as necessary. The virtual human world is modeled by constructing a structure equivalent to the human thinking mechanism of advancing thinking by inquiring of the divine being. This collection of laws of divine existence is a parts repository.

[0299]

As described above, according to the present invention,
Grasping the real world as an object model, associating the real world with an extensional comprehension and a comprehension, placing the comprehension in an information-hidden area, and identifying the comprehension, iD information, so to speak In association with the static world, the real world is represented by the static world, the dynamic world, and the causal world that compose the world of the object by using the extensional name. Gives the mechanism of the system using a class and / or a composite class as a static model, and as a dynamic model for the above dynamic world,
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 a causal relationship generated from the static model and the dynamic model is given as information in the static model. At the time of adopting the configuration, it is possible to construct a configuration that comprehensively and organically manages the attributes of the object.

As a result, the object-oriented data processing system for constructing the object world (virtual human world) by the extensional proposition proposed by the present inventors can be realized and the object parts can be effectively used. become.

[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 a diagram illustrating automation of compatibility diagnosis processing.

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

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

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

FIG. 51: Creation of a parts attribute file for self PR and P
It is a figure explaining the structure of R processing.

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

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

FIG. 54 is an operation flow diagram of program creation using the self-PR function.

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

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

FIG. 57 is an overall configuration diagram of object processing of the present invention.

FIG. 58 is an explanatory diagram of metadata registration processing.

FIG. 59 is an example of metadata.

FIG. 60 is an explanatory diagram of metadata creation processing.

FIG. 61 is an explanatory diagram of a metadata creation form.

FIG. 62 is an explanatory diagram of how to make a comment.

FIG. 63 is an explanatory diagram of how to create a comment.

FIG. 64 is an explanatory diagram of name / keyword registration processing.

FIG. 65 is an explanatory diagram of name / keyword registration processing.

FIG. 66 is an explanatory diagram of changing / adding metadata items.

FIG. 67 is an explanatory diagram of a usage form of metadata.

FIG. 68 is an explanatory diagram of a search process using metadata.

FIG. 69 is an explanatory diagram of signature generation processing.

FIG. 70 is an explanatory diagram of signature addition processing.

71 is an explanatory diagram of a usage pattern of a signature. FIG.

72 is an explanatory diagram of a relationship between knowledge and extension / inclusion.

FIG. 73 is an explanatory diagram of a dictionary configuration.

FIG. 74 is an explanatory diagram of a parts repository.

[Explanation of symbols]

 204 Command / link processing unit 205 Component attribute file 205 'Execution processing data file 212 Dynamic object processing unit 215 Direct object processing expansion processing 220 Object management unit 221 Display 222 Hyper language processing unit

 ─────────────────────────────────────────────────── ─── 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 (12)

[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. In addition, the configuration is such that the attributes of the object are managed as metadata, and the management data that describes the management information of the object, the semantic data that describes the meaning of the object, and the structure of the object are used as the metadata. Object-oriented data processing characterized by being configured to have gene data to describe, an internal iD describing information about the substance of an object, and enoversion data describing a history of evolutionary degeneration of an object. system. 2. The object-oriented data processing system according to claim 1, wherein when metadata is newly generated, a signature that encodes a part or all of the metadata is generated and the generated metadata is generated. An object-oriented data processing system, characterized in that, when data is added or changed, a corresponding signature is added and changed accordingly, and the signature is managed as one of metadata. . 3. The object-oriented data processing system according to claim 2, wherein when the signature is added or changed, the metadata is adapted to change accordingly. 4. The object-oriented data processing system according to claim 2, wherein the signature has a variable data length, and when the metadata is added, the non-additional signature part is left as it is. At the same time, an object-oriented data processing system characterized by being configured to add signatures corresponding to the addition. 5. The object-oriented data processing system according to claim 4, wherein the signature has a header information, and the header information is changed in response to the addition of the signature. Characteristic object-oriented data processing system. 6. The object-oriented data processing system according to claim 1, wherein when a new object is generated, the metadata of the object is calculated from the metadata of the generation source object and the composite information. An object-oriented data processing system characterized by being configured to create. 7. The object-oriented data processing system according to any one of claims 1 to 6, wherein the semantic data of the metadata is the self-P of the object.
An object-oriented data processing system characterized by being configured to output as R information. 8. The object-oriented data processing system according to claim 1, wherein, as one of the semantic data, a comment that expresses a connection relationship of objects that form a composite object in a schema language is prepared, and the comment is An object-oriented data processing system characterized by being configured to create complex objects as they are created. 9. The object-oriented data processing system according to any one of claims 1 to 8, wherein the object-oriented data processing system is configured to be adapted to an object so that a meta item of metadata can be freely added and changed. Data processing system. 10. The object-oriented data processing system according to claim 1, further comprising: a description of semantic data of metadata of the object, which is assigned to an object, and a name which is an identifier of the object. If there is a request to assign the same meaning data with different names in the assignment process, replace the names, or
An object-oriented data processing system characterized in that any one of them is assigned as a keyword, and when there is a request to assign a different name to partially matching semantic data, it is assigned as a keyword. 11. The object-oriented data processing system according to claim 10, wherein the metadata of the object can be referred to by using the name of the object as a search key, and the metadata of the object by using the keyword of the object as a search key. The object-oriented data processing system is characterized in that it is configured to be able to refer to and perform a specified search process on the metadata of the object by using a part of the metadata of the object as a search key. . 12. The object-oriented data processing system according to any one of claims 2 to 11, which is composed of a server and a client and indicates an inclusive i
When the data processing is executed by transferring an object command composed of D information and a signature, a simple dictionary used for extension interpretation of the signature is developed for the client, and the server is processed. The detailed information about the comprehension is expanded to the client, the client interprets the object command transferred according to the simplified dictionary, and when the detailed information about the comprehension needs to be obtained, the server concerned. An object-oriented data processing system characterized by being configured to make inquiries to.