PatentDe  


Dokumentenidentifikation EP0880093 07.08.2003
EP-Veröffentlichungsnummer 0880093
Titel Informationsverarbeitungsvorrichtung
Anmelder Fujitsu Ltd., Kawasaki, Kanagawa, JP
Erfinder Nishigaya, Takashi, Nakahara-ku, Kanagawa 211, JP;
Iida, Ichiro, Nakahara-ku, Kanagawa 211, JP
Vertreter W. Seeger und Kollegen, 81369 München
DE-Aktenzeichen 69815946
Vertragsstaaten DE, FR, GB
Sprache des Dokument EN
EP-Anmeldetag 20.01.1998
EP-Aktenzeichen 983003831
EP-Offenlegungsdatum 25.11.1998
EP date of grant 02.07.2003
Veröffentlichungstag im Patentblatt 07.08.2003
IPC-Hauptklasse G06F 9/46
IPC-Nebenklasse G06F 9/44   

Beschreibung[en]
Background of the Invention Field of the Invention

The present invention relates to an information processing apparatus and is specifically applicable when performing distributed object-oriented programming, etc.

Description of the Prior Art

Conventionally, a distributed system can be easily developed because a method can be issued to an object in a remote computer as in the case of issuing a method to an object in a local computer using distributed object-oriented technology such as CORBA (common object request broker architecture), DCOM (distributed component object model), JavaRMI (Java remote method invocation), etc.

However, since the conventional distributed object-oriented technology has no functions of replacing a part of a program code of a server object being operated or adding a part of a program code with new functionality from a remote computer, distributed objects cannot be smoothly managed.

For example, when a program for a new inquiry command is to be executed in a database server object, the server object should be terminated and reset in such a way that a newly added program can be available to the server object, and then it should be activated again.

Therefore, with an increasing number of server objects associated with an updated service, a longer time is taken to stop the service because it normally takes a long time to add or update a program code of a server object in a distributed system.

Additionally, there has been the performance problem in case that the distributed system has a severe influence of a network delay when a plurality of methods are invoked for the same object, or when a large amount of data is passed through a method's parameters or a return value.

Furthermore, the number of method interfaces of a server object should be increased for diversification to utilize the server object for general purposes or to customize a client side program using the server object interfaces.

Therefore, in the conventional distributed system, the complicated server interfaces increase the difficulty of application development and the service response delay.

Furthermore, the conventional distributed system has the problem that an administrator has heavy responsibility in maintaining and managing the security of the interface when program code is added or updated.

Yau, Stephen S. et al, 'AN OBJECT-ORIENTED APPROACH TO SOFTWARE DEVELOPMENT FOR PARALLEL PROCESSING SYSTEMS' PROCEEDINGS OF THE INTERNATIONAL COMPUTER SOFTWARE AND APPLICATIONS CONFERENCE. (COMPSAC), TOKYO, SEPT. 11-13, 1991, no. CONF. 15, 11 September 1991, pages 453-458, XP000260562 KNAFL G J, discloses classes with methods, whereby simultaneous access to a method of a class object is permitted but must be serialized by means of guards that are attached to the methods and that are implementing locks. Usually with object oriented classes a method may set class data variables that belong to a class object or to the set of all objects for a class type as a whole.

WO 94/01819A by Ericsson Telefon AB discloses a method for changing software during computer operation, where the server receives and installs a new server class for replacing an old server class and allows during computer operation that from a given time point on all operations are processed on the new server class only and the old server class is not used anymore.

Summary of the Invention

Thus, the first object of the present invention is to delete or replace a part of program code without stopping the program being operated.

The second object of the present invention is to easily customize a program without programmer's knowledge of class management.

The third object of the present invention is to improve the security of the interface when program code is added or updated in a distributed system.

According to the present invention, there is provided an information processing apparatus as defined in appended claim 1 for operating a program formed by class data.

Thus, a program can be formed by class data, and the utilization of the program can be monitored for each piece of added class data. As a result, the class data being used can be recognized while the program is operated, and a part of the program code can be deleted or replaced during the execution of the program.

The present invention includes an agent class for generating an agent class object for monitoring the utilization of class data, and generates an agent class object according to the agent class when an operation is performed in the class data.

Thus, the function of monitoring a program can be easily added to the program to be monitored, the utilization of the program can be easily monitored without programmer's knowledge about class management, and a part of the program code can be deleted or replaced while the program is running.

Moreover, in the present invention, an agent class generates a class management object for managing class data added to an agent class object each time a request to add class data is issued.

Thus, a program can be monitored for each function newly added to the program, and when the program is running, it can be determined which function of the program is being used. Therefore, only specifying the function of a part of the program can delete or replace the function of the program while the program is running.

Preferably, the apparatus of the invention stores the relation between the class management object generated according to a class data addition request and identification information about the class management object.

Thus, only specifying identification information such as a name of a class management object, etc. deletes and replaces a part of program code while the program is running, thereby reducing the load of the programmer when customizing the program.

In a preferred embodiment of the present invention, a class management object includes a local class data table for storing class data specific to the class management object.

Thus, even when a conflict between the class data transmitted from another object and the class data being managed by a class management object occurs, the class data transmitted from another object and the class data being managed by a class management object can be independently stored, and an agent class object can remotely process the class data transmitted from another object.

Also, in the preferred embodiment of the present invention, a class management object includes a deletion flag for storing a class data deletion request.

Thus, a class data deletion request can be stored and accepted while the class data specified by the data deletion request is being used. As a result, it is not necessary to reissue a class data deletion request after the request is once rejected. Because the actual deletion of the class data is managed to be deferred, the load of the programmer can be reduced.

Furthermore, in the preferred embodiment, a class management object includes a replacement class data storage area for storing new class data when class data replacement request is issued.

Thus, new class data can be stored when a replacement request is issued, and a class data replacement request can be accepted while the class data specified by the class data replacement request is being used. As a result, it is not necessary to reissue a class data replacement request after the request is once rejected. Because the actual deletion of the class data is managed to be deferred, the load of the programmer can be reduced.

As another feature of the preferred embodiment, a class management object includes a running thread list for storing identification information about a thread which is processing class data.

Thus, only referencing the running thread list determines whether or not class data being processed exists, and the utilization of the class data can be easily checked.

In the preferred embodiment of the present invention, a class management object also includes a class name list for storing a class name of added class data.

Thus, the class management object can easily check the class data managed by itself, and can process class data for each piece of added class data.

A still further feature of the preferred embodiment is that a class management object includes a reference object list for storing identification information about the class management object which manages class data referenced by certain class data, and a referenced object list for storing identification information about a class management object which manages class data referencing certain class data.

Thus, an operation can be performed on class data in consideration of the references of the class data, and the programmer does not have to recognize the references of the class data. Therefore, the program can be easily customized.

In another embodiment of the present invention, an agent class includes an access control class for checking access privileges from an object of another agent class.

Thus, an agent class object can generate an access control object based on an access control class when another agent class object gains access. Therefore, each time an agent class object gains access, access privileges are checked and an access conditions can be easily amended for each agent class object, thereby improving the security of the interface in adding or updating program code.

In the present invention, the public remote method interface comprises class data addition means for adding class data to an agent class object.

Therefore, during the execution of a program, class data can be newly added for the program.

An embodiment of the present invention includes a class management object generation unit for generating a class management object for class data added to an agent class object; a class name registration unit for registering a class name of class data in a class name list in the class management object; a class data table write unit for writing the class data in a shared class data table; and a class management object table registration unit for registering identification information about the class management object in a class management object table.

Thus, the agent class object can monitor the utilization of each item of added class data, easily specify the added data, and perform an operation on the class data.

In an embodiment of the present invention, when a class name of class data added to an agent class object matches a class name of class data registered in a shared class data table, the class data added to the agent class object is removed from the shared class data table.

Thus, a conflict in the same class in the shared class data table can be avoided.

In the present invention, the public remote method interface includes class data processing means for processing class data stored in an agent class object.

Thus, the agent class object can execute an operation represented by class data.

In an embodiment of the present invention, when class data being processed references other class data, execution information is set for a class management object which manages the class data being processed, and is also set for a class management object which manages the referenced class data.

Thus, even if a request to delete or replace the referenced class data is issued while the referencing class data is being processed, the deletion or replacement of the referenced class data can be temporarily held until the end of the process of the referencing class data, thereby avoiding unsuccessfully terminating the process on the class data.

In a further embodiment of the present invention, when a running thread list is empty and a deletion flag of a class management object is set TRUE, class data corresponding to the class name in the class name list of the class management object is removed from the shared class data table.

Thus, after completing the function of a part of a program specified in a deletion request, the function of the part of the program can be deleted. Therefore; suspending the program being executed or reactivating the program can be avoided when the function of the part of the program is requested to be deleted.

In a still further embodiment of the present invention, when a running thread list is empty and a replacement class data storage area stores class data, class data to be replaced and stored in the shared class data table is replaced with the class data stored in the replacement class data storage area.

Thus, after completing the function of a part of a program specified in a replacement request, the function of the part of the program can be replaced with another function. Therefore, suspending the program being executed or reactivating the program can be avoided when the function of the part of the program is requested to be replaced.

The public remote method interface may further comprise class data deletion means for deleting class data from an agent class object.

Thus, the agent class object can delete a part of a program.

According to an embodiment of the present invention, when identification information about a thread is set in a running thread list of a class management object, the deletion of class data processed by the thread is suspended, and a deletion flag of the class management object is set TRUE.

Thus, even when a deletion request is issued for class data being processed, the deletion request for the class data can be accepted without stopping processing the class data. Therefore, the class data can be requested to be deleted without affecting the process on the class data.

The public remote method interface may further comprise class data replacement means for replacing class data of an agent class object.

Thus, the agent class object can replace a part of a program.

In another embodiment of the present invention, when identification information about a thread is set in a running thread list of a class management object, the replacement of class data processed by the thread is suspended, and new class data is set in a replacement class data storage area of the class management object.

Thus, even when a replacement request is issued for class data being processed, the replacement request for the class data can be accepted without stopping processing the class data. Therefore, the class data can be requested to be replaced without affecting the process on the class data.

According to a further embodiment of the present invention, when a deletion or replacement request is issued, an error notification is transmitted when a referenced object list of a class management object is not empty, and identification information about a referencing class management object is deleted from a referenced object list of a referenced class management object when a reference object list of the class management object is not empty.

Thus, class data referenced by another class data can be prevented from being lost, and unnecessary information can be deleted, thereby improving the convenience when a program is customized.

According to another embodiment of the present invention, an agent class object can remotely execute a program using a public remote method interface for processing class data transmitted from another agent class object.

A further feature in one embodiment is to store class data transmitted from another agent class object in a local class data table of a class management object.

Thus, a remote execution can be smoothly performed by an agent class object such that a conflict can be avoided between the class data and class data already stored for the class management object.

According to another embodiment of the present invention, based on class data and serialized data of an object generated from the class data, the object generated from the class data is restored.

Thus, the object generated from the class data is- transmitted to another agent class object, and the object can be remotely processed.

According to a further embodiment of the present invention, class data to be processed and class data referenced by the class data to be processed are transmitted to another agent class object.

Thus, class data having reference relationship can be remotely processed.

In a still further embodiment of the present invention, class data in a destination agent class object is removed, and class data to be processed is transmitted to the destination agent class object.

Thus, the amount of communications in a remote execution can be reduced, and the remote execution speed can be enhanced.

In yet another embodiment of the present invention, the execution state of a program including a plurality of functions is monitored for each function, and a process is performed on a function of the program based on the execution state of the program.

Thus, when the function of a part of a program is not executed during the execution of the program, or when the function of apart of the program is completed during the execution of the program, the function of the part can be deleted or replaced during the execution of the program, thereby quickly customizing the program.

Brief Description of the Drawings

The present invention will be more apparent from the following detailed description, when taken in conjunction with the accompanying drawings, in which;

  • FIG. 1 is a block diagram showing the functional configuration of the information processing apparatus according to an embodiment of the present invention;
  • FIG. 2 is a block diagram showing an example of the configuration of the class data process unit shown in FIG. 1;
  • FIG. 3 is a block diagram showing the functional configuration of the computer according to an embodiment of the present invention;
  • FIG. 4 shows an example of the configuration of the class management object shown in FIG. 3;
  • FIG. 5 shows an example of the configuration of an agent class;
  • FIG. 6 shows a method of generating a class management object when class data is added;
  • FIG. 7 shows an example of coding a template;
  • FIG. 8 shows an example of the system configuration of the computer shown in FIG. 3;
  • FIG. 9 is a flowchart showing an operation of the communication daemon shown in FIG. 3;
  • FIG. 10 is a flowchart showing an operation of the communication thread shown in FIG. 3;
  • FIG. 11 shows the state in which class data is added to an agent class object;
  • FIG. 12 shows the state in which referenced class data is added to an agent class object;
  • FIG. 13 shows the method of deleting an overlapping class data from an agent class object;
  • FIG. 14 is a flowchart showing a class data adding process;
  • FIG. 15 is a flowchart showing an access privileges checking process;
  • FIG. 16 is a flowchart showing a class data fetching process;
  • FIG. 17 shows the state of an agent class object when class data is processed;
  • FIG. 18 shows the state of an agent class object when referenced class data is processed;
  • FIG. 19 is a flowchart showing a class data process;
  • FIG. 20 shows the state of an agent class object when a deletion request is issued while class data is processed;
  • FIG. 21 is a flowchart showing a class data deleting process;
  • FIG. 22 shows the state of an agent class object when a replacement request is issued while class data is processed;
  • FIG. 23 shows the state of an agent class object after replacing class data;
  • FIG. 24 is a flowchart showing a class data replacing process;
  • FIG. 25 is a flowchart (continued) showing a class data replacing process;
  • FIG. 26 shows the state of an agent class object when class data is remotely evaluated;
  • FIG. 27 shows the state of an agent class object when serialized data is remotely evaluated;
  • FIG. 28 is a flowchart showing a remote evaluation;
  • FIG. 29 shows the state of an agent class object when referenced class data is remotely evaluated;
  • FIG. 30 shows the state of an agent class object when overlapping class data is remotely evaluated; and
  • FIG. 31 is a flowchart showing a class retrieving process.

Description of the Preferred Embodiments

The embodiments of the present invention are described below by referring to the attached drawings.

FIG. 1 is a block diagram showing the functional configuration of the information processing apparatus according to an embodiment of the present invention.

In FIG. 1, a class data storage unit 1 stores class data added to an object. A class data monitor unit 2 monitors the utilization of the class data stored in the class data storage unit 1 for each piece of added class data. A class data process unit 3 processes the class data for each piece of added class data based on the utilization of the class data monitored by the class data monitor unit 2.

With the above described configuration, the class data monitor unit 2 can monitor a program for each function newly added to the program. While the program is running, it can be determined which function of the program is being used. As a result, the class data process unit 3 can process the function of a part of the program during the operation of the program only by specifying the function of the part of the program.

FIG. 2 is a block diagram showing an example of the configuration of the class data process unit 3 shown in FIG. 1.

In FIG. 2, a reception unit 11 receives a deletion request, a replacement request, etc. for the class data stored in the class data storage unit 1. A determination unit 12 determines whether or not the class data specified by the deletion request, the replacement request, etc. is being used based on the monitor result from the class data monitor unit 2. A delay unit 13 delays the deletion, replacement, etc. of the class data until the use of the class data has been completed if the class data is being used.

When a deletion request or a replacement request for class data being processed is issued, the reception unit 11 receives the deletion request or the replacement request for the class data without stopping processing the class data. The delay unit 13 identifies whether or not the use of the class data to be deleted or replaced has been completed by referring to the determination result from the determination unit 12, and performs a process specified by a deletion request, a replacement request, etc. received by the reception unit 11 after the use of the class data to be deleted or replaced is completed.

After the execution of the function of a part of a program specified by a deletion request or a replacement request is completed, the function of the part of the program can be deleted, replaced with another function, etc. When the function of the part of the program is deleted, replaced, etc., it is not required to suspend or reactivate the program being executed.

FIG. 3 is a block diagram showing the functional configuration of the computer according to an embodiment of the present invention.

In FIG. 3, an agent class is provided as a basic class of a library of a development language, and the agent class is stored in an agent class library 31. When developing a system, the programmer describes an application by generating a subclass based on an agent class as a basic class.

An agent class includes a class management object table 23 for storing the correspondence between class management objects 24a through 24m and the names of the class management objects 24a through 24m; the class management objects 24a through 24m for managing class data added to agent class objects 22a through 22n; a shared class data table 25 for storing the class data managed by the class management objects 24a through 24m; and public remote method interfaces 26 for performing a process on class data.

The agent class objects 22a through 22n are generated in a computer 21 as instances of an agent class stored in the agent class library 31. For example, the names function-1 through function-m of the class management objects 24a through 24m are registered in the class management object table 23 of the agent class object 22a. Simultaneously, the pointers to the class management objects 24a through 24m respectively corresponding to the names function-1 through function-m are stored therein.

For example, a remove () method 26a, an add () method 26b, a get () method 26c, a set () method 26d, an eval () method 26e, and a call () method 26f are provided as the public remote method interfaces 26 for the agent class object 22a.

The remove () method 26a deletes class data from the shared class data table 25 using as arguments the names of the class management objects 24a through 24m which manage class data to be deleted.

The add () method 26b newly generates the class management objects 24a through 24m which manage class data to be added using as arguments the class data to be added and the names of the class management objects 24a through 24m which manage the class data to be added. Simultaneously, the add () method 26b registers the names of the class management objects 24a through 24m in the class management object table 23, and stores the class data to be added in the shared class data table 25.

The get () method 26c copies class data from the shared class data table 25 using as arguments the names of the class management objects 24a through 24m which manage class data to be fetched.

The set () method 26d replaces class data to be replaced in the shared class data table 25 with new class data using as arguments new replacing class data and the names of the class management objects 24a through 24m which manage the class data to be replaced.

The eval () method 26e performs a remote process on class data or the object of the class data using as arguments class data to be processed and serialized data of an object of the class data.

The call () method 26f generates an object from class data stored in the shared class data table 25 using as arguments the names of the class management objects 24a through 24m which manage the class data to be processed.

The computer 21 includes a communication daemon 28; a network socket API (application programming interface) 29; an operating system 30; and a system class library 32.

When the public remote method interface 26 is invoked, communication threads 27a through 27k are assigned, and there can be a plurality of execution flows (for example, methods and functions) performed in parallel in a program with a data area shared among them. The multiple thread function is a standard function in the Java language, etc.

The communications of information among the agent class objects 22a through 22n in the computer 21 and the communications of information between the computer 21 and another computer are established through a network socket API.

The class replacement function and the remote execution function of the agent class objects 22a through 22n are applied to an actual system as, for example, a remote maintenance of software. Using these class replacement function and the remote execution function, software can be remotely replaced without stopping a server, and these functions can be used on a plurality of servers in a batch process.

Therefore, when a program is amended with only a part of server software replaced, it is not necessary to stop the server and then reactivate it after the program is amended. Especially when a distributed system is adopted, the load of an administrator can be considerably reduced. Actually, a general application can be flexibly customized by generating a class operating in the agent class objects 22a through 22n.

Thus, according to the embodiment shown in FIG. 3, when a plurality of agent class objects 22a through 22n are linked and the active agent class objects 22a through 22n receive an addition request or a deletion request for the class data which is a program code forming the agent class objects 22a through 22n, the shared class data table 25 is provided in each of the agent class objects 22a through 22n to generate the class management objects 24a through 24m each time an addition request is issued.

When the class management objects 24a through 24m manage the search in the shared class data table 25 and the execution and deletion of an added class group, the added class group can be shared and a partial class group can be dynamically deleted and updated.

Furthermore, by replacing a program or remotely executing a part of a program in a run time environment, flexible linkage and dynamic load balancing can be realized in a distributed network management system, a distributed network service, a distributed groupware, etc.

Furthermore, a program code of an active server object can be added and updated during the operation of the server object, and a server object associated with an updated service does not have to be completely stopped. As a result, a service can be stopped for a considerably short time.

An agent refers to an object provided with a function of monitoring class data forming the object.

FIG. 4 shows an example of the configuration of the management object shown in FIG. 3.

In FIG. 4, the class management objects 24a through 24m includes a local class data table (local classes) 41; a deletion flag (removable flag) 42; a replacement class data storage area (next classes) 43; a running thread ID list (running threads) 44; a class name list (class names) 45; a reference object list (referring) 46; a referenced object list (referred) 47; and a class search function 48 for retrieving class data.

The local class data table 41 stores class data received during the remote execution of the program. That is, when the class data is transmitted from any of other agent class objects 22a through 22n during the remote execution, the local class data table 41 stores the class data independently of the class data already managed by the class management objects 24a through 24m, thereby avoiding the conflict between the transmitted class data and the class data already managed by the class management objects 24a through 24m when the class data is remotely processed.

The deletion flag 42 indicates whether or not a request to delete class data added to the shared class data table 25 has been issued. The request to delete the class data can be accepted even when the class data specified by the deletion request is being used by storing the request to delete the class data in the deletion flag 42.

The replacement class data storage area 43 temporarily stores newly replacing class data when a request to replace class data added to the shared class data table 25. The request to replace the class data can be accepted even when the class data specified by the request to replace the class data is being used by storing the new class data in the replacement class data storage area 43 at the issue of a replacement request.

The running thread ID list 44 stores a thread ID which is processing class data added to the shared class data table 25. It can be determined by storing the thread ID in the running thread ID list 44 and referring to the running thread ID list 44 whether or not the class data exists.

The class name list 45 stores each class name of class data added to the shared class data table 25. The class data managed by the class management objects 24a through 24m can be checked, and a process can be performed for each piece of the class data managed by the class management objects 24a through 24m.

The reference object list 46 shows which one of the class management objects 24a through 24m manages the class data utilized by the class data added to the shared class data table 25. The reference object list 46 enables a process on the class data to be performed in consideration of referenced class data.

The referenced object list 47 shows which one of the class management objects 24a through 24m manages class data utilizing other class data, and a process can be performed on class data in consideration of the referencing class data.

FIG. 5 shows an example of the configuration of the agent class.

An agent class is provided as a basic class 52 of a class library 51. The basic class 52 includes a class management object table 53, a class management object 54, a shared class data table 55, and a public remote method interface 56. A subclass 57 generated from the basic class 52 is registered in the class library 51, and the agent class objects 22a through 22n can be generated as instances 58a through 58j from the subclass 57.

Thus, a developer of a distributed system can realize the function of replacing class data in a run time environment by generating the subclass 57 of an agent class and describing an application without special knowledge about class management, and can generate a flexible system using a remote execution function by transmitting class data from external agent class objects 22a through 22n.

FIG. 6 shows a method of generating a class management object when class data is added.

In FIG. 6, for example, when class data A, class data B, and class data C are added to an agent class object 301 using the name 'function-1', they are stored in a shared class data table 302, and simultaneously a class management object 303 for managing the class data A, B, and C is generated.

The class names of the class data A, B, and C managed by the class management object 303 are registered in the class management object 303, and 'function-1' is registered as the name of the class management object 303 in the class management object table.

If class data D and E are added as the name 'function-2' to the agent class object 301 after the class data A, B, and C are added to the agent class object 301, the class data D and E are stored in the shared class data table 302, and a class management object 304 for managing the class data D and E is newly generated.

The class names of the class data D and E managed by the class management object 304 are registered in the class management object 304, and 'function-2' is registered as the name of the class management object 304 in the class management object table.

If class data F, G, and H are added as the name 'function-3' to the agent class object 301 after the class data D and E are added to the agent class object 301, the class data F, G, and H are stored in the shared class data table 302, and a class management object 305 for managing the class data F, G, and H is newly generated.

The class names of the class data F, G, and H managed by the class management object 305 are registered in the class management object 305, and 'function-3' is registered as the name of the class management object 305 in the class management object table.

Thus, each time a function formed by class data is added to the agent class object 301, the class management objects 303 through 305 are generated. As a result, a program can be monitored for each function formed by class data, and it can be determined which function of the program is being used during the operation of the program. Therefore, the function of a part of the program can be deleted or replaced during the operation of the program.

Furthermore, if the names 'function-1' through 'function-3' of the class management objects 303 through 305 are registered in the class management object table, the programmer can specify the function added to a program by specifying the names 'function-1' through 'function-3' of the class management objects 303 through 305, thereby improving the convenience in customizing the program.

Described below is the method of customizing the application according to an embodiment of the present invention.

FIG. 7 shows an example of coding a template.

Assume that, in FIG. 7, for example, the application for screening the E-mail arrival notification is provided in a template (model) format using an initialization file. The template is used to screen the arrival notification about the mail from a specified sender. Selecting 'From' from a pop-up menu 82 of a field column 83 of an initialization menu 81 and inputting the name of the sender through the keyboard sets the name of the sender in a contents column 84.

On the other hand, when a keyword is to be retrieved from the body of the E-mail and screened, it cannot be successfully retrieved only through the functions provided by the template shown in FIG. 7. Therefore, a program code for searching the text of the E-mail for a keyword is obtained externally. Then, the program code for the portion of the arrival notification of the E-mail provided by the template shown in FIG. 7 is replaced with the program code for retrieving a keyword of the text of the E-mail.

When a program code is replaced, the class management objects 24a through 24m monitor the utilization of a program code for a portion of the arrival notification of E-mail. This allows the program code to be replaced when the program code for the portion of the arrival notification of E-mail is not executed. Therefore, when the template shown in FIG. 7 is customized, a part of the function of the program in the template format shown in FIG. 7 can be replaced without stopping the operation of the program in the template format shown in FIG. 7.

Thus, a program to be customized is operated and a program code required for an application to be established can be retrieved for replacement by coding the template and monitoring the program code for each function. Therefore, an application can be flexibly customized without limitations from the current template.

FIG. 8 shows an example of the system configuration of the computer shown in FIG. 3.

In FIG. 8, a CPU 61, a RAM 62, a ROM 63, a communication interface 64, a printer 65, a display 66, a keyboard 67, a mouse 68, and a driver 69 are interconnected. For example, a hard disk 70, a floppy disk 71, a magnetic tape 72, an optical disk 73 such as a CD-ROM, a DVD-ROM, etc., and an IC memory card 74 are connected to the driver 69.

An agent class is stored in the ROM 63, the hard disk 70, the floppy disk 71, the magnetic tape 72, the optical disk 73 such as a CD-ROM, DVD-ROM, etc., the IC memory card 74, etc. When the agent class objects 22a through 22n are activated from the agent class, the agent class objects 22a through 22n are generated under the control of the CPU 61 and stored in the RAM 62. The operations on the agent class objects 22a through 22n are performed by operating the screen in the template format shown on the display 66 or inputting data through the keyboard.

Furthermore, a program can be transmitted or received through the communication interface 64. The communication network connected to the communication interface 64 can be, for example, a LAN (local area network), a WAN (wide area network), the Internet, an analog telephone network, a digital telephone network (ISDN: integrated services digital network), and a wireless communication network used in a PHS (personal handy system), etc.

FIG. 9 is a flowchart showing the operations of the communication daemon 28 shown in FIG. 3.

In FIG. 9, when the communication daemon 28 receives a message from another computer through the network socket API 29 in a state of waiting for a message (step S1), the names AGENT-1 through AGENT-n of the destination agent class objects 22a through 22n, a method name, and an argument are obtained from the message (step S2), and the communication threads 27a through 27k are generated (step S3). Then, the data obtained from the other computer is passed to the communication threads 27a through 27k.

FIG. 10 is a flowchart showing the operations of the communication threads 27a through 27k shown in FIG. 3.

In FIG. 10, when the communication threads 27a through 27k are generated from the communication daemon 28 (step S11), the agent class objects 22a through 22n are specified by the names AGENT-1 through AGENT-n of the agent class objects 22a through 22n specified by the communication daemon 28 (step S12).

Next, the communication threads 27a through 27k calls the public remote method interface 26 for the specified agent class objects 22a through 22n by setting an argument transmitted from the communication daemon 28 (step S13), and awaits a return value from the agent class objects 22a through 22n (step S14).

Upon receipt of a return value of the public remote method interface 26 from the agent class objects 22a through 22n, the communication threads 27a through 27k control the network socket API 29 to return a message containing the return value to an agent class object of another computer which issued the public remote method interface 26 (step S15), and delete the communication threads 27a through 27k (step S16).

Described below is the method of adding class data to the agent class objects 22a through 22n.

FIG. 11 shows the state in which class data is added to an agent class object.

In FIG. 11, for example, when a function comprising the class data A, B, and C is added to an agent class object 101 using the name 'function-1', the class data A, B, and C are stored in a shared class data table 104, and a class management object 103 for managing the class data A, B, and C is generated. The 'function-1' is registered as the name of the class management object 103 in a class management object table 102. Corresponding to the name 'function-1' of the class management object 103, a pointer to the class management object 103 is generated in the class management object table 102.

The class names A, B, and C of the respective class data A, B, and C managed by the class management object 103 are registered in the class name list (class names) of the class management object 103, and a deletion flag (removable flag) is set FALSE. The local class data table (local classes), the replacement class data storage area (next classes), the running thread ID list (running threads), the reference object list (referring), and the referenced object list (referred) are null.

FIG. 12 shows the state in which class data having reference relationship is added to an agent class object.

In FIG. 12, for example, the function comprising the class data A, B, and C is added as the name 'function-1' to an agent class object 111. The class data A, B, and C are stored in a shared class data table 115, and a class management object 113 for managing the class data A, B, and C is generated.

The class names A, B, and C of the respective class data A, B, and C managed by the class management object 113 are registered in the class name list (class names) of the class management object 113, and a deletion flag (removable flag) is set FALSE. The local class data table (local classes), the replacement class data storage area (next classes), the running thread ID list (running threads), and the reference object list (referring) are null.

The 'function-1' is registered as the name of the class management object 113 in a class management object table 112. Corresponding to the name 'function-1' of the class management object 113, a pointer to the class management object 113 is generated in the class management object table 112.

In this state, when a function comprising the class data F and G is added to an agent class object 111 using the name 'function-3', the class data F and G are added to a shared class data table 115.

Then, a class management object 114 for managing the class data F and G is newly generated. The 'function-3' is registered as'the name of the class management object 114 in a class management object table 112. Corresponding to the name 'function-3' of the class management object 114, a pointer to the class management object 114 is newly generated in the class management object table 112.

The class names F and G of the respective class data F and G managed by the class management object 114 are registered in the class name list (class names) of the class management object 114, and a deletion flag (removable flag) is set FALSE. The local class data table (local classes), the replacement class data storage area (next classes), the running thread ID list (running threads), and the referenced object list (referred) are null.

Assume that the class data F is based on the existence of the class data A already added to the shared class data table 115 as follows.

The reference object list (referring) of the class management object 114 stores the reference information about the class management object 113 for managing the referenced class data A, and the referenced object list (referred) of the class management object 113 stores the referenced information about the class management object 114 which manages the referencing class data F.

Therefore, even when the remove () method 26a and the set () method 26d are invoked using the name 'function-1' as an argument, and a deletion request and a replacement request for a function comprising the class data A, B, and C is issued to the agent class object 111, the class management object 113 can hold the deletion request and the replacement request for the function comprising the class data A, B, and C by checking the referenced object list. Thus, the function of the class data F which refers to the class data A can be protected against ruins.

FIG. 13 shows the method of rejecting double registration of class data in the agent class objects 22a through 22n.

In FIG. 13, for example, a function comprising the class data A, B, and C is added to an agent class object 121 using the name 'function-1', the class data A, B, and C are stored in a shared class data table 124, and a class management object 123 for managing the class data A, B, and C is generated.

The class names A, B, and C of the respective class data A, B, and C managed by the class management object 123 are registered in the class name list (class names) of the class management object 123, and a deletion flag (removable flag) is set FALSE. The local class data table (local classes), the replacement class data storage area (next classes), the running thread ID list (running threads), the reference object list (referring), and the referenced object list (referred) are null.

The 'function-1' is registered as the name of the class management object 123 in a class management object table 122. Corresponding to the name 'function-1' of the class management object 123, a pointer to the class management object 123 is generated in the class management object table 122.

In this state, when an add () method 125 of the agent class object 121 is invoked using the name 'function-6', the class data D, E, and A as arguments, the class data D is newly stored in a shared class data table 124 after confirming that the class data D is not stored in the shared class data table 124 of the agent class object 121.

Next, after confirming that the class data E is not stored in the shared class data table 124, the class data E is newly stored in the shared class data table 124.

When the class data A is stored in the shared class data table 124, the class data D and E are deleted from the shared class data table 124 because the class data A has already been stored in the shared class data table 124. The class data D, E, and A having the name 'function-6' are not stored in the shared class data table 124.

When the agent class object 121 receives a request to simultaneously add or replace plural pieces of class data, the shared class data table 124 is restored to its original state by deleting all class data to be added in the shared class data table 124 if a conflict arises between a part of the class names to be added and the class names existing in the agent class object 121 during the class data adding process.

FIG. 14 is a flowchart showing the class data adding process.

When the agent class objects 22a through 22n add class data, the add () method 26b is invoked.

First, in FIG. 14, access privileges to the agent class objects 22a through 22n is checked (step S21). If there are no access privileges, the process is suspended.

Then, the names 'function-1' through 'function-m' assigned when the class data is added and the class data to be added are obtained from the argument of the add () method 26b (step S22), and the names 'function-1' through 'function-m' assigned when the class data is added are retrieved from the class management object table 23 (step S23).

Next, it is checked whether or not the names 'function-1' through 'function-m' assigned when the class data is added exist in the class management object table 23 (step S24). If the names 'function-1' through 'function-m' assigned when the class data is added exist in the class management object table 23, an error notification is issued and the process is suspended (step S25).

On the other hand, if the names 'function-1' through 'function-m' assigned when the class data is added do not exist in the class management object table 23, the class data specified by the addition request is written to the shared class data table 25 (step S26).

Then, it is determined whether or not the same class name exists in the shared class data table 25 (step S27). If it is detected while the class data is being written that the same class name exists in the shared class data table 25, then the class data stored in the shared class data table 25 at the addition request is deleted, the shared class data table 25 is restored to its original state (step S28), an error notification is issued, and the process terminates (step S29).

On the other hand, if all class data specified at an addition request have been successfully added because the same class name does not exist in the shared class data table 25 when the class data is written, then the class management objects 24a through 24m are newly generated. The names 'function-1' through 'function-m' assigned when the class data set by the argument of the add () method 26b are registered in the class management object table 23 so that the newly generated class management objects 24a through 24m can be identified by the names 'function-1' through 'function-m' registered in the class management object table 23 (step S30).

Then, the class names of all class data added to the shared class data table 25 are set in the class name list 45 of the newly generated class management objects 24a through 24m (step S31).

Next, the class related to the class data added to the shared class data table 25 is checked, destination information is set in the reference object list 46 of the newly generated class management objects 24a through 24m (step S32), and source information is set in the referenced object list 47 of the referenced class management objects 24a through 24m (step S33), thereby terminating the process.

Described below is the method of controlling access privileges according to an embodiment of the present invention.

Assume that the process for checking access privileges at the replacement of a class is reserved by the name, for example, 'CheckSet', and the following class is added to the agent class objects 22a through 22n by the name 'CheckSet'.

Before registering the class data, access control conditions are checked using the requesting user name, the host name, and the names 'AGENT-1' through 'AGENT-n' of the agent class objects 22a through 22n, etc. to determine whether or not the request to process the class data is acceptable. That is, if the operating agent class objects 22a through 22n accept a deletion request or a replacement request for the class data, an object is generated from the class named 'CheckSet' for execution.

In this case, unless the name of the agent that has issued a class data replacement request matches 'Admin', the replacing process is not performed, but an exception occurs. Since the class describing the access control conditions, is processed in the same manner as other classes in the agent class objects 22a through 22n, the access control conditions being effective can be amended. That is, the access control conditions are managed as replaceable class data in the agent class objects 22a through 22n, and the access control conditions on the operating agent class objects 22a through 22n can be amended.

Thus, even when a program is added or updated from a remote computer, the interface is secured in adding and updating a program code, thereby reducing the load of the administrator of the maintenance and management of distributed objects.

FIG. 15 is a flowchart showing the access privileges checking process.

The access privileges checking process is invoked by a process of adding class data to the agent class objects 22a through 22n shown in FIG. 13; a process of obtaining the class data shown in FIG. 16; a process performed on the class data shown in FIG. 19; a process of deleting class data shown in FIG. 21; a process of replacing class data shown in FIGs. 24 and 25; and a class data remote process shown in FIG. 28.

In FIG. 15, when an access privileges check is started (step S41), the class of the access privileges check describing the access control conditions is retrieved from the shared class data table 25 (step S42). Then, it is checked whether or not the class for checking access privileges exists in the shared class data table 25 (step S43). If the class exists in the shared class data table 25, an object is generated from the class of the access privileges check for execution (step S44).

The class of the access privileges check refers to a program describing rules according to the type and argument of a process, the names AGENT-1 through AGENT-n of the agent class objects 22a through 22n, the process requesting user names, etc., and can be replaced with another class of the access privileges check during the operations of the agent class objects 22a through 22n as with other class data added to the agent class objects 22a through 22n.

Therefore, the access control conditions can be easily amended for each of the agent class objects 22a through 22n, thereby improving the security of the interface in adding and updating a program code.

On the other hand, if the class of the access privileges check does not exist in the shared class data table 25, the access privileges are checked under the default conditions (step S45).

Then, it is determined whether or not access privileges exist (step S46). If no access privileges exist, an error notification is issued (step S47) and the process terminates (step S47). If access privileges exist, the agent class objects 22a through 22n accepts a requested process (step S48).

Described below is the method of obtaining the class data from the agent class objects 22a through 22n.

FIG. 16 is a flowchart showing the process of obtaining class data.

When the agent class objects 22a through 22n performs a process of obtaining class data, the get () method 26c is invoked.

In FIG. 16, access privileges are checked first on the agent class objects 22a through 22n (step S51). If no access privileges exist, the process terminates.

Next, the names 'function-1' through 'function-m' of the class management objects 24a through 24m for managing the class data to be processed are obtained from the argument of the get () method 26c (step S52), and the names 'function-1' through 'function-m' of the class management objects 24a through 24m for managing the class data to be processed are retrieved from the class management object table 23 (step S53).

Then, it is checked whether or not the names 'function-1' through 'function-m' of the class management objects 24a through 24m for managing the class data to be processed are registered in the class management object table 23 (step S54). If the names 'function-1' through 'function-m' of the class management objects 24a through 24m for managing the class data to be processed are not registered in the class management object table 23, an error notification is issued and the process is suspended (step S55).

If the names 'function-1' through 'function-m' of the class management objects 24a through 24m for managing the class data to be processed are registered in the class management object table 23, then the class names are obtained from the class name list 45 of the class management objects 24a through 24m, the class data of the class name is copied from the shared class data table 25 (step S56), and the class data is returned as a return value to the requester (step S37).

Described below is the method of processing class data in the agent class objects 22a through 22n.

FIG. 17 shows the state of an agent class object when the class data is processed.

In FIG. 17, for example, the function comprising the class data A, B, and C is added as the name 'function-1' to an agent class object 131. The class data A, B, and C are stored in a shared class data table 135, and a class management object 133 for managing the class data A, B, and C is generated.

The class names A, B, and C of the respective class data A, B, and C managed by the class management object 133 are registered in the class name list (class names) of the class management object 133, and a deletion flag (removable flag) is set FALSE. The local class data table (local classes), the replacement class data storage area (next classes), the reference object list (referring), and referenced object list (referred) are null.

The 'function-1' is registered as the name of the class management object 133 in a class management object table 132. Corresponding to the name 'function-1' of the class management object 133, a pointer to the class management object 133 is generated in the class management object table 132.

When a request to process the class data A, B, and C is issued to the agent class object 131 by specifying the name 'function-1', the objects A, B, and C are generated from the class data A, B, and C, and a thread 134 is assigned.

The running thread ID list (running threads) stores identification information about the thread 134 assigned to the objects A, B, and C. When the objects A, B, and C have been processed, the identification information about the thread 134 assigned to the objects A, B, and C is deleted from the running thread ID list (running threads).

Therefore, the class management object 133 can easily determine whether or not the class data A, B, and C managed by the class management object 133 are being used by referring to the running thread ID list (running threads).

FIG. 18 shows the state of an agent class object whose class data having reference relationship is being processed.

In FIG. 18, for example, the function comprising the class data A, B, and C is added as the name 'function-1' to an agent class object 141. The class data A, B, and C are stored in a shared class data table 147, and a class management object 143 for managing the class data A, B, and C is generated.

The class names A, B, and C of the respective class data A, B, and C managed by the class management object 143 are registered in the class name list (class names) of the class management object 143, and a deletion flag (removable flag) is set FALSE. The local class data table (local classes), the replacement class data storage area (next classes), and the reference object list (referring) are null.

The 'function-1' is registered as the name of the class management object 143 in a class management object table 142. Corresponding to the name 'function-1' of the class management object 143, a pointer to the class management object 143 is generated in the class management object table 142.

The function comprising the class data D is added as the name 'function-4' to an agent class object 141. The class data D are stored in a shared class data table 147, and a class management object 145 for managing the class data D is generated.

The class name D of the class data D managed by the class management object 145 is registered in the class name list (class names) of the class management object 145, and a deletion flag (removable flag) is set FALSE. The local class data table (local classes), the replacement class data storage area (next classes), and the referenced object list (referred) are null.

The 'function-4' is registered as the name of the class management object 145 in a class management object table 142. Corresponding to the name 'function-4' of the class management object 145, a pointer to the class management object 145 is generated in the class management object table 142.

Assume that the class data D is based on, for example, the existence of the class data A and B as follows.

The reference object list (referring) of the class management object 145 stores the reference information about the class management object 143 for managing the referenced class data A and B, and the referenced object list (referred) of the class management object 143 stores the referenced information about the class management object 145 which manages the referencing class data D.

In this state, when a request to process the class data D is issued to the agent class object 141 by specifying the name 'function-4', the object D is generated from the class data D, and a thread 144 is assigned.

The running thread ID list (running threads) of the class management object 145 stores the identification information of the thread 144 assigned to the object D, and the running thread ID list (running threads) of the class management object 143 for managing class data A and B referred to by the class D also stores the identification information of the thread 144 assigned to the object D.

When the execution of the object D is completed, the identification information about the thread 144 assigned to the object D is deleted from the running thread ID list (running threads) of the class management object 143 and the class management object 145.

Therefore, even if a request to delete or add the function named 'function-1' is issued to the agent class object 141 during the execution of the function named 'function-4', the class management object 143 can hold the request to delete or add the function named 'function-1' by checking its own running thread ID list (running threads), thereby preventing the execution of the function named 'function-4' from being rejected during the execution of the function named 'function-4'

FIG. 19 is a flowchart showing the process performed on class data.

When the agent class objects 22a through 22n performs a process on the class data, the call () method 26f is invoked.

In FIG. 19, access privileges are checked first on the agent class objects 22a through 22n (step S61). If no access privileges exist, the process terminates.

Next, the names 'function-1' through 'function-m' of the class management objects 24a through 24m for managing the class data to be processed are obtained from the argument of the call () method 26f (step S62), and the names 'function-1' through 'function-m' of the class management objects 24a through 24m for managing the class data to be processed are retrieved from the class management object table 23 (step S63).

Then, it is checked whether or not the names 'function-1' through 'function-m' of the class management objects 24a through 24m for managing the class data to be processed are registered in the class management object table 23 (step S64). If the names 'function-1' through 'function-m' of the class management objects 24a through 24m for managing the class data to be processed are not registered in the class management object table 23, an error notification is issued and the process is suspended (step S65).

If the names 'function-1' through 'function-m' of the class management objects 24a through 24m for managing the class data to be processed are registered in the class management object table 23, then the running thread ID is added to the running thread ID list 44 of the class management objects 24a through 24m, and the running thread ID is added to the running thread ID list 44 of the class management objects 24a through 24m shown in the reference object list 46 of the class management objects 24a through 24m (step S66).

Then, an object is generated from the class data to be processed (step S67), and the end of the process is awaited (step S68).

When the process terminates, the running thread ID is deleted from the running thread ID list 44 of the class management objects 24a through 24m, and the running thread ID is deleted from the running thread ID list 44 of the class management objects 24a through 24m shown in the reference object list 46 of the class management objects 24a through 24m (step S69).

It is checked whether or not the running thread ID list 44 is empty (step S70). If the running thread ID list 44 is not empty, the execution process terminates (step S71). When the running thread ID list 44 is empty, it is checked whether or not the deletion flag 42 is TRUE (step S72). If the deletion flag 42 is TRUE, then the deleting process is reserved, and the deleting process shown in FIG. 21 is invoked (step S73) and the execution process terminates (step S74).

If the deletion flag 42 is FALSE, it is checked whether or not the replacement class data storage area 43 is empty (step S75). If the replacement class data storage area 43 is empty, the execution process terminates (step S76). If the replacement class data storage area 43 is not empty, the replacing process is reserved, and the replacing process shown in FIGS. 24 and 25 are invoked using as an argument the class data stored in the replacement class data storage area 43 (step S77), thereby terminating the execution process.

When the operating agent class objects 22a through 22n accept a request to delete or replace class data, the class management objects 24a through 24m monitor the utilization of each class data. As a result, the deletion or replacement of the class data can be delayed until the class data to be deleted or replaced become unavailable, thereby successfully processing the class data deletion or replacement request without stopping the operating agent class objects 22a through 22n.

When a class data deletion or replacement request is issued to the operating agent class objects 22a through 22n, a stop request can be issued to an object which is using the class data to be deleted or replaced so that the class data can be deleted after the response from the object.

Described below is the method of deleting class data from the agent class objects 22a through 22n.

FIG. 20 shows the state of an agent class object when a deletion request is issued when the class data is processed.

In FIG. 20, for example, the function comprising the class data A, B, and C is added as the name 'function-1' to an agent class object 151. The class data A, B, and C are stored in a shared class data table 155, and a class management object 153 for managing the class data A, B, and C is generated.

The class names A, B, and C of the respective class data A, B, and C managed by the class management object 153 are registered in the class name list (class names) of the class management object 153. The local class data table (local classes), the replacement class data storage area (next classes), the reference object list (referring), and referenced object list (referred) are null.

The 'function-1' is registered as the name of the class management object 153 in a class management object table 152. Corresponding to the name 'function-1' of the class management object 153, a pointer to the class management object 153 is generated in the class management object table 152.

Furthermore, when the function named 'function-1' is performed, the objects A, B, and C are generated from the class data A, B, and C, and are assigned a thread 154. Simultaneously, the running thread ID list (running threads) stores identification information about the thread 154 assigned to the objects A, B, and C.

In this state, when the name 'function-1' is specified and a deletion request for the class data A, B, and C is issued, the class management object 153 refers to a running thread ID list (running threads), and confirms the utilization of the class data A, B, and C.

In this case, since a running thread ID list (running threads) contains the identification information about the thread 154, it is recognized that the class data A, B, and C are being used, a deletion request for the class data A, B, and C are held, a deletion flag (removable flag) is set TRUE, and the deletion request for the class data A, B, and C is stored.

When the function named 'function-1' is completely performed, the identification information about the thread 154 is deleted from the running thread ID list (running threads), and the class management object 153 confirms whether or not a deletion request for the class data A, B, and C has been issued by referring to the state of the deletion flag (removable flag).

Since the deletion flag (removable flag) is TRUE, the class data A, B, and C are successfully deleted at this time.

When a strong deletion request is issued, the function named 'function-1' being performed is suspended to immediately delete the class data A, B, and C.

FIG. 21 is a flowchart showing a class data deleting process.

When the agent class objects 22a through 22n delete class data, the remove () method 26a is invoked.

In FIG. 21, access privileges are checked first on the agent class objects 22a through 22n (step S81). If no access privileges exist, the process terminates.

Next, the names 'function-1' through 'function-m' of the class management objects 24a through 24m for managing the class data to be deleted are obtained from the argument of the remove () method 26a (step S82), and the names 'function-1' through 'function-m' of the class management objects 24a through 24m for managing the class data to be deleted are retrieved from the class management object table 23 (step S83).

Then, it is checked whether or not the names 'function-1' through 'function-m' of the class management-objects 24a through 24m for managing the class data to be deleted are registered in the class management object table 23 (step S84). If the names 'function-1' through 'function-m' of the class management objects 24a through 24m for managing the class data to be deleted are not registered in the class management object table 23, an error notification is issued and the process is suspended (step S85).

If the names 'function-1' through 'function-m' of the class management objects 24a through 24m for managing the class data to be deleted are registered in the class management object table 23, it is checked whether or not the running thread ID list 44 is empty (step S86). If the running thread ID list 44 is not empty, the deletion flag 42 of the class management objects 24a through 24m is set TRUE (step S87), thereby terminating the deleting process (step S88).

If the running thread ID list 44 is empty, it is checked whether or not the referenced object list 47 is also empty (step S89). If the referenced object list 47 is not empty, an error notification is issued and a deleting process is suspended (step S90).

If the referenced object list 47 is empty, it is checked whether or not the reference object list 46 is also empty (step S91). If the reference object list 46 is not empty, then the referenced information about the class management objects 24a through 24m are deleted from the referenced object list 47 of each of the class management objects 24a through 24m shown in the reference object list 46 (step S92).

On the other hand, if the reference object list 46 is empty, the class management objects 24a through 24m specify the class data to be deleted from the shared class data table 25 by referring to the class name list 45, and delete the class data having the class name registered in the class name list 45 of the class management objects 24a through 24m from the shared class data table (step S93).

Then, the names 'function-1' through 'function-m' of the class management objects 24a through 24m are deleted from the class management object table 23, and the deleting process terminates.

Described below is the method of replacing the class data of the agent class objects 22a through 22n.

FIG. 22 shows the state of the agent class object when a replacement request is issued when the class data is processed. In this example, the function named 'function-1' comprising the class data A, B, and C is replaced with the function named 'function-2' comprising the class data D and E.

In FIG. 22, for example, the function comprising the class data A, B, and C is added as the name 'function-1' to an agent class object 161. The class data A, B, and C are stored in a shared class data table 165, and a class management object 163 for managing the class data A, B, and C is generated.

The class names A, B, and C of the respective class data A, B, and C managed by the class management object 163 are registered in the class name list (class names) of the class management object 163, and a deletion flag (removable flag) is set FALSE. The local class data table (local classes), the reference object list (referring), and the referenced object list (referred) are null.

The 'function-1' is registered as the name of the class management object 163 in a class management object table 162. Corresponding to the name 'function-1' of the class management object 163, a pointer to the class management object 163 is generated in the class management object table 162.

Furthermore, when the function named 'function-1' is performed, the objects A, B, and C are generated from the class data A, B, and C, and are assigned a thread 164. Simultaneously, the running thread ID list (running threads) stores identification information about the thread 164 assigned to the objects A, B, and C.

In this state, when the name 'function-1' is specified and a replacement request for the class data A, B, and C is issued, the class management object 163 refers to a running thread ID list (running threads), and confirms the utilization of the class data A, B, and C.

In this case, since a running thread ID list (running threads) contains the identification information about the thread 164, it is recognized that the class data A, B, and C are being used, a replacement request for the class data A, B, and C are held, and the class data D and E to replace the class data A, B, and C are stored in the replacement class data storage area (next classes).

When the function named 'function-1' is completely performed, the identification information about the thread 164 is deleted from the running thread ID list (running threads), and the class management object 163 confirms whether or not a replacement request for the class data A, B, and C has been issued by referring to the state of the replacement class data storage area (next classes).

In this example, since the replacement class data storage area (next classes) stores the class data D and E, the class data A, B, and C are successfully replaced with the class data D and E.

When a strong replacement request is issued, the function named 'function-1' being performed is suspended to immediately replace the class data A, B, and C.

FIG. 23 shows the state of the agent class object after the replacement the class data.

In FIG. 23, when the class data A, B, and C are replaced with the class data D and E, the class data D and E are deleted from the replacement class data storage area (next classes) of the class management object 163 shown in FIG. 22, and the class names A, B, and C of the class data A, B, and C registered in the class name list (class names) shown in FIG. 22 are replaced with the class names D and E of the class data D and E. Thus, the class management object 163 shown in FIG. 22 is updated to a class management object 173.

The class data A, B, and C stored in the shared class data table 165 shown in FIG. 22 are replaced with the class data D and E, and the shared class data table 165 shown in FIG. 22 is updated to a shared class data table 174 shown in FIG. 23.

Furthermore, the name 'function-1' of the class data A, B, and C registered in the class management object table 162 shown in FIG. 22 is replaced with the name 'function-2 of the class data D and E, and the class management object table 162 shown in FIG. 22 is updated to a class management object table 172 shown in FIG. 23.

FIGs. 24 and 25 are flowcharts showing the class data replacing process.

When the agent class objects 22a through 22n perform the class data deleting process, the set () method 26d is invoked.

In FIG. 24, access privileges are checked first on the agent class objects 22a through 22n (step S101). If no access privileges exist, the process terminates.

Next, the names 'function-1' through 'function-m' of the class management objects 24a through 24m for managing the class data to be replaced and new replacing class data are obtained from the argument of the set () method 26d (step S102), and the names 'function-1' through 'function-m' of the class management objects 24a through 24m for managing the class data to be replaced are retrieved from the class management object table 23 (step S103).

Then, it is checked whether or not the names 'function-1' through 'function-m' of the class management objects 24a through 24m for managing the class data to be replaced are registered in the class management object table 23 (step S104). If the names 'function-1' through 'function-m' of the class management objects 24a through 24m for managing the class data to be replaced are not registered in the class management object table 23, an error notification is issued and the process is suspended (step S105).

If the names 'function-1' through 'function-m' of the class management objects 24a through 24m for managing the class data to be replaced are registered in the class management object table 23, it is checked whether or not the running thread ID list 44 is empty (step S106). If the running thread ID list 44 is not empty, the class data obtained from the argument of the set () method 26d is set in the replacement class data storage area 43 (step S107), thereby terminating the replacing process (step S108).

If the running thread ID list 44 is empty, it is checked whether or not the referenced object list 47 is also empty (step S109). If the referenced object list 47 is not empty, an error notification is issued and a deleting process is suspended (step S110).

If the referenced object list 47 is empty, it is checked whether or not the reference object list 46 is also empty (step Sill). If the reference object list 46 is not empty, then the referenced information about the class management objects 24a through 24m are deleted from the referenced object list 47 of each of the class management objects 24a through 24m shown in the reference object list 46 (step S112).

On the other hand, if the reference object list 46 is empty, the class management objects 24a through 24m specify the class data to be deleted from the shared class data table 25 by referring to the class name list 45, and delete the class data having the class name registered in the class name list 45 of the class management objects 24a through 24m from the shared class data table (step S113).

As shown in FIG. 25, new class data specified by a replacement request is written to the shared class data table 25 (step S114).

Then, it is determined whether or not the same class name exists in the shared class data table 25 (step S115). If the same class name exists in the shared class data table 25 while the class data is being written, the class data newly stored in the shared class data table 25 is deleted, and the shared class data table 25 is restored to its original state (step S116), an error notification is issued, and the process terminates (step S117).

If the same class name does not exist in the shared class data table 25, then the class names of all class data newly added to the shared class data table 25 are set in the class name list 45 of the class management objects 24a through 24m (step S118).

Then, by checking the class related to the class data added to the shared class data table 25, destination information is set in the reference object list 46 of the class management objects 24a through 24m (step S119), and source information is set in the referenced object list 47 of the class management objects 24a through 24m (step S120), thereby terminating the process.

Described below is the method of remotely processing class data in the agent class objects 22a through 22n.

FIG. 26 shows the state of the agent class object while the class data is remotely evaluated.

In FIG. 26, for example, the function comprising the class data A, B, and C is added as the name 'function-1' to an agent class object 181. The class data A, B, and C are stored in a shared class data table 185, and a class management object 183 for managing the class data A, B, and C is generated.

The class names A, B, and C of the respective class data A, B, and C managed by the class management object 183 are registered in the class name list (class names) of the class management object 183, and a deletion flag (removable flag) is set FALSE. The local class data table (local classes), the replacement class data storage area (next classes), the running thread ID list (running threads), the reference object list (referring), and the referenced object list (referred) are null.

The 'function-1' is registered as the name of the class management object 183 in a class management object table 182, and a pointer to a class management object 183 is generated in the class management object 183 corresponding to the name function-1 of the class management object table 182.

When an eval () method 186 is invoked for the agent class object 181 using as arguments the class data D, E, and A, a class management object 184 is newly generated. The class data D, E, and A are stored in the local class table (local classes) of the class management object 184. The class name list (class names) of the class management object 184 stores the class names D, E, and A of the class data D, E, and A respectively.

The deletion flag (removable flag) of the class management object 184 is set FALSE, and the replacement class data storage area (next classes), the running thread ID list (running threads), the reference object list (referring), and the referenced object list (referred) are null.

Thus, if the function comprising the class data D, E, and A is added to the agent class object 181, the class data D, E, and A are stored in the local class data table (local classes) of the class management object 184. Therefore, even if the class data A is registered in the shared class data table 185, the conflict of the same class name A can be avoided in the shared class data table 185, and the function comprising the class data D, E, and A can be performed.

The method of storing the class data D, E, and A in the local class data table (local classes) of the class management object 184 is effective when the frequency of the use of the function comprising the class data D, E, and A is low or when the class data to be processed can be frequently amended.

FIG. 27 shows the state of the agent class object when serialized data is remotely evaluated.

In FIG. 27, the class data D is stored in a shared class data table 192 of an agent class object 191, and is defined as having an object of a class String and an object of a class Integer as attributes. An instance 193 of the class data D is generated in the agent class object 191.

When the agent class object 191 invokes an eval () method 195 of an agent class object 194 using as arguments the class data D and the instance 193 of the class data D, the agent class object 191 serializes the instance 193 of the class data D.

Then, the class data D and the serialized data of the instance 193 are set as arguments of the eval () method 195, and transmits 'D' {Strings;Integer i;}, 'D', String, '19:50AM', Integer, '19:50AM'.

When the eval () method 195 is invoked, the agent class object 194 generates a class management object 196, and stores the contents {Strings; Ingeger i;) of the class data D in the local class data table (local classes) of the class management object 196, and stores the class name D of the class data D in the class name list (class names) of the class management object 196.

The deletion flag (removable flag) of the class management object 196 is set FALSE, and the replacement class data storage area (next classes), the running thread ID list (running threads), the reference object list (referring), and the referenced object list (referred) are null.

Furthermore, based on the class data D and the serialized data of the instance 193, an instance 197 obtained by restoring the instance 193 of the agent class object 191 is generated, and the class data D and the instance 197 are processed.

Thus, when the agent class object 194 receives from another agent class object 191, the class data and the serialized data of an object generated from the class data, the agent class object 194 does not generate a new object from the received class data, but the source object is restored from the received class data and the serialized data, thereby in a remote executing process, the instance 193 of the other agent class object 191 can be processed.

FIG. 28 is a flowchart showing a remote evaluation process.

When the agent class objects 22a through 22n perform the class data remote process, the eval () method 26e is invoked.

In FIG. 28, access privileges are checked first on the agent class objects 22a through 22n (step S130). If no access privileges exist, the process terminates.

Next, the class data and the serialized object data are obtained from the argument of the eval () method 26e (step S131) to newly generate the class management objects 24a through 24m for managing the class data, and to set the class data of the argument in the local class data table 41 of the class management objects 24a through 24m (step S132).

Then, by checking the class related to the class data added to the local class data table 41, the destination information is set in the reference object list 46 of the class management objects 24a through 24m (step S133), and the source information is set in the referenced object list 47 of the referenced class management objects 24a through 24m (step S134).

A running thread ID is added to the running thread ID list 44 of the class management objects 24a through 24m, and the running thread ID is added to the running thread ID list 44 of the class management objects 24a through 24m shown in the reference object list 46 of the class management objects 24a through 24m (step S135).

Then, it is checked whether or not serialized object data exists in the argument of the eval () method 26e (step S136). If no serialized object data exists in the argument of the eval () method 26e, then an object is generated from the class data to be processed and the object is processed (step S137), and the end of the process on the object is awaited (step S139).

If serialized object data exists in the argument of the eval () method 26e, then the object is restored using the serialized object data and the class data in the local class data table 41, and the object is processed (step S138).

When the process is completed, then the running thread ID is deleted from the running thread ID list 44 of the class management objects 24a through 24m, and the running thread ID is deleted from the running thread ID list 44 of the class management objects 24a through 24m shown in the reference object list 46 of the class management objects 24a through 24m (step S140).

Then, the referenced information about the class management objects 24a through 24m is deleted from the referenced object list 47 of each of the class management objects 24a through 24m shown in the reference object list 46 (step S141), and the class management objects 24a through 24m for managing the class data to be processed are deleted (step S142).

FIG. 29 shows the state of the agent class object when class data having reference relationship is remotely processed.

In FIG. 29, for example, the function comprising the class data A, B, and C is added as the name 'function-1' to an agent class object 201. The class data A, B, and C are stored in a shared class data table 206, and a class management object 203 for managing the class data A, B, and C is generated.

The class names A, B, and C of the respective class data A, B, and C managed by the class management object 203 are registered in the class name list (class names) of the class management object 203. The deletion flag (removable flag) is set FALSE, and the local class data table (local classes), the replacement class data storage area (next classes), the running thread ID list (running threads), and the reference object list (referring) are null.

The 'function-1' is registered as the name of the class management object 203 in a class management object table 202. Corresponding to the name 'function-1' of the class management object 203, a pointer to the class management object 203 is generated in the class management object table 202.

Furthermore, a function which is named 'function-4' and comprises the class data D is added to the agent class object 201. The class data D is stored in the shared class data table 206, and a class management object 204 for managing the class data D is generated.

The class name D of the class data D managed by the class management object 204 are registered in the class name list (class names) of the class management object 204. The deletion flag (removable flag) is set FALSE, and the local class data table (local classes), the replacement class data storage area (next classes), the running thread ID list (running threads), and the referenced object list (referred) are null.

The 'function-4' is registered as the name of the class management object 204 in a class management object table 202. Corresponding to the name 'function-4' of the class management object 204, a pointer to the class management object 204 is generated in the class management object table 202.

Assume that the class data D is based on, for example, the existence of the class data A and B as follows.

The reference object list (referring) of the class management object 204 stores the reference information about the class management object 203 for managing the referenced class data A and B, and the referenced object list (referred) of the class management object 203 stores the referenced information about the class management object 204 which manages the referencing class data D.

The relation in invoking a class can be checked using, for example, in the Java language, getDeclaredClasses () which is a class method.

In this state, when the agent class object 201 issues a request to remotely process the class data D with the name 'function-4 specified, a thread 205 is generated, the class data D is transmitted together with the class data A, B, and C managed by the class management object 203 shown in the reference object list (referring) of the class management object 204.

The class data A, B, and C managed by the class management object 203 and the class data D managed by the class management object 204 are stored in the shared class data table 206 of the agent class object 201 and managed by the same agent class object 201. Therefore, the class data A and B referenced by the class data d can be easily obtained.

Thus, the relation in invoking a class to be remotely processed and another class required when the class is processed is checked before the transfer of the class data. When the class data to be remotely processed is transmitted, another class data required in processing the class data is transmitted together. As a result, the load of the process can be reduced at the destination especially when class data are stored as distributed, for example, in a distributed system, etc.

FIG. 30 shows the state of the agent class object when overlapping class data are remotely evaluated.

In FIG. 30, for example, a function which is named 'function-5' and comprises the class data A, D, and E is added to the agent class object 211. The class data A, D, and E are stored in the shared class data table 214, and a class management object 213 for managing the class data A, D, and E is generated.

The class names A, D, and E of the respective class data A, D, and E managed by the class management object 213 are registered in the class name list (class names) of the class management object 213. The deletion flag (removable flag) is set FALSE, and the local class data table (local classes), the replacement class data storage area (next classes), the running thread ID list (running threads), the reference object list (referring), and the referenced object list (referred) are null.

The 'function-5' is registered as the name of the class management object 213 in a class management object table 212. Corresponding to the name 'function-5' of the class management object 213, a pointer to the class management object 213 is generated in the class management object table 212.

Furthermore, a function which is named 'function-1' and comprises the class data A, B, and C is added to the agent class object 215. The class data A, B, and C are stored in the shared class data table 218, and a class management object 217 for managing the class data A, B, and C is generated.

The class names A, B, and C of the respective class data A, B, and C managed by the class management object 217 are registered in the class name list (class names) of the class management object 217. The deletion flag (removable flag) is set FALSE, and the local class data table (local classes), the replacement class data storage area (next classes), the running thread ID list (running threads), the reference object list (referring), and the referenced object list (referred) are null.

The name 'function-1' is registered as the name of the class management object 217 in a class management object table 216. The pointer to the class management object 217 is generated in the class management object table 216 corresponding to the name 'function-1' of the class management object 217.

When the agent class object 211 remotely executes the function named 'function-5' through an agent class object 215, it is inquired whether or not the class data D, E, and A forming the function named 'function-5' exist in the shared class data table 218 of the agent class object 215.

The agent class object 215 checks whether or not the class data D, E, and A exist in the shared class data table 218. Among the class data D, E, and A, it is recognized that the class data A exists in the shared class data table 218. Then, the information about the existence of the class data A is returned to the agent class object 211.

When the agent class object 211 is notified of the existence of the class data A, it transfers only the class data D and E to the agent class object 215, from the class data D, E, and A to be transferred to the agent class object 215.

The agent class object 215 uses the class data D and E transferred from the agent class object 211, and also uses the class data A stored in the shared class data table 218, thereby performing the function named 'function-5'.

Thus, it is not necessary to transmit the class data stored in the transferred-to shared class data table when a remote evaluation is performed, and the amount of transfer of the class data can be reduced.

Described below is the method of retrieving class data by the agent class objects 22a through 22n.

The class management objects 24a through 24m have the class search function 48, and invoke the loadClass () method of the class management objects 24a through 24m when an object is generated from the class data added to the agent class objects 22a through 22n, or when an object is generated from the class data declared in the method of the object.

FIG. 31 is a flowchart showing the class retrieving process.

In FIG. 31, the class name of the class data to be retrieved is fetched from the arguments of the loadClass () method (step S151), and the local class data table 41 is searched (step S152). Then, the result of searching the local class data table 41 is checked (step S153). When the class data to be retrieved is found, the class data is returned as a return value (step S158).

If the class data to be retrieved is not found in the local class data table 41, the shared class data table 25 is searched (step S154). Then, the result of searching the shared class data table 25 is checked (step S155). When the class data to be retrieved is found, the class data is returned as a return value (step S158).

If the class data to be retrieved is not found in the shared class data table 25, the agent class library 31 and the system class library 32 are searched (step S156). Then, the result of searching the agent class library 31 and the system class library 32 is checked (step S157). If the class data to be retrieved is found, the class data is returned as a return value (step S158).

If the class data to be retrieved is not found in the agent class library 31 or the system class library 32, then an error notification is issued and the process terminates (step S159).

As described above, according to the present invention, an agent class is provided with distributed objects having the functions of replacing and remotely processing class data. Therefore, a flexible distributed object system can be easily operated, and a developer can utilize these function easily and securely without knowledge of class management.

The present invention is described above, but is not limited to the above described embodiments, and can be varied within the technological concept of the present invention.

In an embodiment of the invention as described above, a program can be monitored for each piece of class data having added utilization data of the program. As a result, the class data being used can be recognized while the program is operated, and a part of the program code can be deleted or replaced during the execution of the program.

Even if a process request for deletion, replacement, etc. is issued to a program being executed, the program can be deleted or replaced without stopping the operation of the program, thereby reducing the load of the programmer when customizing the program.

A monitor object for monitoring the utilization of class data is provided in an object to be monitored. The function of monitoring a program can be easily added to the program to be monitored, the utilization of the program can be easily monitored without programmer's knowledge about class management, and a part of a program code can be deleted or replaced while the program is running.

A monitor object can be generated each time an addition request for class data is issued. A program can be monitored for each function newly added to the program, and when the program is running, it can be determined which function of the program is being used. Therefore, only specifying the function of a part of the program can delete or replace the function of the program while the program is running.

If identification information about a class management object is stored, then only specifying identification information such as a name of a class management object, etc. deletes or replaces a part of a program code while the program is running, thereby reducing the load of the programmer when customizing the program.

A class management object can include a local class data table for storing class data specific to the class management object. Thus, even when there is a conflict between the class data transmitted from another object and the class data being managed by a class management object, the class data transmitted from another object and the class data being managed by a class management object can be independently stored, and an agent class object can remotely evaluate the class data transmitted from another object.

A class data deletion request can be stored and accepted while the class data specified by the data deletion request is being used. As a result, it is not necessary to reissue a class data deletion request after the request is once rejected. Therefore, when the class data is deleted, the load of the programmer can be reduced.

New class data can be stored when a replacement request is issued, and a class data replacement request can be accepted while the class data specified by the class data replacement request is being used. As a result, it is not necessary to reissue a class data replacement request after the request is once rejected. Therefore, when the class data is replaced, the load of the programmer can be reduced.

If a thread which is processing class data is stored, only referencing the running thread list determines whether or not class data being processed exists, and the utilization of the class data can be easily checked.

If a class name corresponding to added class data is stored, then the class management object can easily check the class data managed by itself, and can process class data for each piece of added class data.

The reference of class data can be stored in a class management object. A process can be performed on class data in consideration of the references of the class data, and the programmer does not have to recognize the reference relationship of the class data. Therefore, the program can be easily customized.

An agent class object includes an access control class for checking access privileges from another agent class object. An agent class object can generate an access control object based on an access control class when another agent class object gains access. Therefore, each time an agent class object gains access, access privileges can be checked and an access condition can be easily amended for each agent class object, thereby improving the security of the interface in adding to or updating a program code.

Class names of class data are different from each other. A conflict in the same class in the shared class data table can be avoided.

When a request to delete or replace the referenced class data is issued while the referencing class data is being processed, the deletion or replacement of the referenced class data can be temporarily held until the end of the process of the referencing class data, thereby avoiding unsuccessfully terminating the process on the class data.

After completing the function of a part of a program specified in a deletion or replacement request, the function of the part of the program can be deleted or replaced. Therefore, suspending the program being executed or reactivating the program can be avoided when the function of the part of the program is deleted or replaced.

An embodiment of the present invention stores class data transmitted from another agent class object in a local class data table of a class management object. Thus, a remote evaluation can be smoothly performed by an agent class object such that a conflict can be avoided between the class data and class data stored already stored for the class management object.

Based on class data and serialized data of an object generated from the class data, the object generated from the class data can be restored.

Thus, the object generated from the class data is serialized and transmitted, the serialized data is restored on a receiving side, and the object can be remotely evaluated.

Class data referenced by the class data to be processed is transmitted to perform a remote evaluation for class data having reference relationship.

By transmitting class data not existing in an agent class object at a destination, the amount of communications in a remote evaluation can be reduced, and the remote execution speed can be enhanced.


Anspruch[de]
  1. Informationsverarbeitungsgerät zum Betreiben eines durch Klassendaten gebildeten Programms, welches Gerät aufweist:
    • ein Benutzerarbeitseinheitsklassen-Speichermittel (31) zum Speichern einer Benutzerarbeitseinheitsklasse, um ein Objekt einer Benutzerarbeitseinheitsklasse zu erzeugen, welches eine Nutzung von Klassendaten überwacht, und
    • ein Erzeugungsmittel für Objekte von Benutzerarbeitseinheitsklassen, um ein besagtes Objekt (22a - 22n) einer Benutzerarbeitseinheitsklasse basierend auf der Benutzerarbeitseinheitsklasse zu erzeugen, wenn ein Prozess an den Klassendaten durchgeführt wird;
       worin das Objekt einer Benutzerarbeitseinheitsklasse aufweist:
    • zumindest ein Klassenverwaltungsobjekt (24a - 24m) zum Verwalten der Klassendaten, die zu dem Objekt (22a - 22n) einer Benutzerarbeitseinheitsklasse addiert wurden;
    • eine Tabelle (25) gemeinsam genutzter Klassendaten zum Speichern der Klassendaten, die durch das eine oder mehrere Klassenverwaltungsobjekte (24a - 24m) verwaltet werden, die durch das Objekt einer Benutzerarbeitseinheitsklasse gebildet werden; und
    • eine Schnittstelle (26) für ein öffentliches Fern-Verfahren zum Durchführen des Prozesses an den Klassendaten;
       worin die Schnittstelle (26) für ein öffentliches Fern-Verfahren aufweist:
    • ein Klassendaten-Additionsmittel zum Addieren von Klassendaten zum Objekt (22a - 22n) einer Benutzerarbeitseinheitsklasse, welche Klassendaten durch ein Klassenverwaltungsobjekt verwaltet werden sollen, das durch das Objekt einer Benutzerarbeitseinheitsklasse gebildet wird, und welche Klassendaten eine zu verarbeitende Funktion repräsentieren;
    • ein Klassendaten-Prozessmittel zum Verarbeiten von Klassendaten, die eine zu verarbeitende Funktion repräsentieren und in dem Objekt (22a - 22n) einer Benutzerarbeitseinheitsklasse gespeichert sind; und
    • ein Klassendaten ersetzendes oder löschendes Mittel, um Klassendaten, die in dem Objekt (22a - 22n) einer Benutzerarbeitseinheitsklasse gespeichert sind, zu ersetzen oder zu löschen;
    • wodurch das Objekt einer Benutzerarbeitseinheitsklasse eine Nutzung von Klassendaten überwacht, um die Klassendaten zu erkennen, die gerade verwendet werden, während das Programm betrieben wird, und als Antwort auf eine Anforderung, Klassendaten zu ersetzen oder zu löschen, falls die angeforderten Klassendaten gerade verwendet werden, die angeforderten Klassendaten ersetzt oder gelöscht werden, nachdem ihre Nutzung geendet hat, ohne eine Operation des Programms zu stoppen.
  2. Gerät nach Anspruch 1, worin

       das Objekt einer Benutzerarbeitseinheitsklasse femer aufweist:
    • eine Tabelle (23) für Klassenverwaltungsobjekte zum Speichern einer Korrespondenz zwischen dem Klassenverwaltungsobjekt (24a - 24m), das für eine Anforderung, die Klassendaten zu addieren, erzeugt wurde, und einem Namen, der zugewiesen wird, wenn die Anforderung, die Klassendaten zu addieren, ausgegeben wird.
  3. Gerät nach Anspruch 2, worin

       das Klassenverwaltungsobjekt (24a - 24m) aufweist:
    • eine Tabelle (41) für lokale Klassendaten, um Klassendaten zu speichern, die für jedes Klassenverwaltungsobjekt (24a - 24m) spezifisch sind;
    • ein Löschungs-Flag (42) zum Speichern einer Anforderung, die Klassendaten zu löschen;
    • einen Speicherbereich (43) für Ersatz-Klassendaten, um neue Klassendaten zu speichern, wenn eine Anforderung, die Klassendaten zu ersetzen, ausgegeben wird;
    • eine ID-Liste (44) laufender Threads zum Speichern einer Identifizierungsinformation über eine Thread-Verarbeitung der Klassendaten;
    • eine Klassennamenliste (45) zum Speichern eines den Klassendaten entsprechenden Klassennamens;
    • eine Referenzobjektliste (46) zum Speichern einer Identifizierungsinformation über ein Klassenverwaltungsobjekt (24a - 24m), welches Klassendaten verwaltet, auf die durch die Klassendaten verwiesen wird; und
    • eine Liste (47) verwiesener Objekte, um eine Identifizierungsinformation über ein Klassenverwaltungsobjekt (24a - 24m) zu speichern, welches Klassendaten verwaltet, wodurch auf die Klassendaten verwiesen wird.
  4. Gerät nach Anspruch 1, worin die Benutzerarbeitseinheitsklasse speichert:
    • eine Zugriffssteuerklasse zum Prüfen von Zugriffsprivilegien eines anderen Objekts (22a - 22n) einer Benutzerarbeitseinheitsklasse in der Tabelle (25) gemeinsam genutzter Klassendaten.
  5. Gerät nach Anspruch 1, worin das Objekt einer Benutzerarbeitseinheitsklasse aufweist:
    • ein Erzeugungsmittel für Zugriffssteuerobjekte, um ein Zugriffssteuerobjekt basierend auf der Zugriffssteuerklasse zu erzeugen, wenn von einem anderen Objekt (22a - 22n) einer Benutzerarbeitseinheitsklasse Zugriff erlangt wird; und
    • ein Ausführungsmittel für Zugriffssteuerobjekte, um Zugriffsprivilegien basierend auf dem Zugriffssteuerobjekt zu prüfen.
  6. Gerät nach Anspruch 1, worin das Klassendaten-Additionsmittel aufweist:
    • ein Erzeugungsmittel für Klassenverwaltungsobjekte, um ein Klassenverwaltungsobjekt (24a - 24m) zu erzeugen, um zu dem Objekt (22a - 22n) einer Benutzerarbeitseinheitsklasse addierte Klassendaten zu verwalten;
    • ein Klassennamen-Registrierungsmittel zum Registrieren eines Klassennamens der Klassendaten in einer Klassennamenliste (45) in dem Klassenverwaltungsobjekt (24a - 24m);
    • ein Klassendaten-Schreibmittel zum Schreiben der Klassendaten in der Tabelle (25) gemeinsam genutzter Klassendaten; und
    • ein Registrierungsmittel für Klassenverwaltungsobjekte, um in der Tabelle (23) für Klassenverwaltungsobjekte einen Namen zu registrieren, der zugewiesen wird, wenn die Anforderung, die Klassendaten zu addieren, ausgegeben wird.
  7. Gerät nach Anspruch 6, worin das Klassendaten-Additionsmittel ferner aufweist:
    • ein Wiederherstellungsmittel für eine Tabelle gemeinsam genutzter Klassendaten, um die Tabelle (25) gemeinsam genutzter Klassendaten in einem ursprünglichen Zustand wiederherzustellen, indem Klassendaten, die zu dem Objekt (22a - 22n) einer Benutzerarbeitseinheitsklasse addiert wurden, aus der Tabelle (25) gemeinsam genutzter Klassendaten gelöscht werden, wenn ein Klassenname von zum Objekt (22a - 22n) einer Benutzerarbeitseinheitsklasse addierten Klassendaten zu einem Klassennamen von Klassendaten passt, die in der Tabelle (25) gemeinsam genutzter Klassendaten registriert sind.
  8. Gerät nach Anspruch 1, worin das Klassendaten-Prozessmittel aufweist:
    • ein erstes Thread-Listen festlegendes Mittel zum Festlegen einer Identifizierungsinformation über eine Thread-Verarbeitung der Klassendaten in einer ID-Liste (44) laufender Threads der Klassenverwaltungsobjekte (24a - 24m), welche Klassendaten verwalten, die gerade verarbeitet werden; und
    • ein zweites Thread-Listen festlegendes Mittel zum Festlegen einer Identifizierungsinformation über eine Thread-Verarbeitung der Klassendaten in einer ID-Liste (44) laufender Threads von Klassenverwaltungsobjekten (24a - 24m), welche Klassendaten verwalten, auf die durch Klassendaten verwiesen wird, die gerade verarbeitet werden.
  9. Gerät nach Anspruch 8, worin das Klassendaten-Prozessmittel aufweist:
    • ein erstes Prüfmittel für Listen laufender Threads, um zu prüfen, ob eine Identifizierungsinformation über ein Thread in der ID-Liste (44) laufender Threads von Klassenverwaltungsobjekten (24a - 24m) festgelegt ist oder nicht;
    • ein Bestimmungsmittel für Löschungs-Flags zum Bestimmen eines Setzens eines Löschungs-Flags (42) des Klassenverwaltungsobjekts (24a - 24m); und
    • ein Löschungs-Ausführungsmittel zum Löschen von Klassendaten entsprechend einem Klassennamen einer Klassennamenliste (45) in einem Klassenverwaltungsobjekt (24a - 24m) aus der Tabelle (25) gemeinsam genutzter Klassendaten, wenn die ID-Liste (44) laufender Threads leer ist und ein Löschungs-Flag (42) des Klassenverwaltungsobjekts (24a - 24m) WAHR ist.
  10. Gerät nach Anspruch 8, worin das Klassendaten-Prozessmittel aufweist:
    • ein zweites Prüfmittel für Listen laufender Threads, um zu prüfen, ob eine Identifizierungsinformation über ein Thread in der ID-Liste (44) laufender Threads von Klassenverwaltungsobjekten (24a - 24m) festgelegt ist oder nicht;
    • ein Mittel zur Abfrage von Ersatz-Klassendaten, um einen Speicherbereich (43) für Ersatz-Klassendaten des Klassenverwaltungsobjekts (24a - 24m) abzufragen; und
    • ein Ersatz-Ausführungsmittel zum Ersetzen von Klassendaten, die ersetzt werden sollen und in der Tabelle (25) gemeinsam genutzter Klassendaten gespeichert sind, wobei die Klassendaten im Speicherbereich (43) für Ersatz-Klassendaten gespeichert sind, wenn die ID-Liste (44) laufender Threads leer ist und Klassendaten eines Klassenverwaltungsobjekts (24a - 24m) im Speicherbereich (43) für Ersatz-Klassendaten gespeichert sind.
  11. Gerät nach Anspruch 1, worin das Klassendaten-Löschungsmittel aufweist:
    • ein drittes Prüfmittel für Listen laufender Threads, um eine ID-Liste (44) laufender Threads von Klassenverwaltungsobjekten (24a - 24m) zu prüfen, welche zu löschende Klassendaten verwalten; und
    • ein Löschungs-Flags setzendes Mittel zum Stoppen eines Löschens der Klassendaten und WAHR-Setzens eines Löschungs-Flags (42) des Klassenverwaltungsobjekts (24a - 24m), wenn eine Identifizierungsinformation über ein Thread in der ID-Liste (44) laufender Threads festgelegt ist.
  12. Gerät nach Anspruch 1, worin das Klassendaten-Ersatzmittel aufweist:
    • ein viertes Prüfmittel für Listen laufender Threads, um eine ID-Liste (44) laufender Threads von Klassenverwaltungsobjekten (24a - 24m) zu prüfen, welche zu ersetzende Klassendaten verwalten;
    • ein Ersatzdaten festlegendes Mittel zum Stoppen eines Ersetzens der Klassendaten und Festlegens neuer Klassendaten in einem Speicherbereich (43) für Ersatz-Klassendaten des Klassenverwaltungsobjekts (24a - 24m), wenn eine Identifizierungsinformation über ein Thread in der ID-Liste (44) laufender Threads festgelegt ist.
  13. Gerät nach Anspruch 11 oder 12, ferner aufweisend:
    • ein Fehlerbenachrichtigungsmittel zum Ausgeben einer Fehlerbenachrichtigung, wenn eine Liste (47) verwiesener Objekte der Klassenverwaltungsobjekte (24a - 24m) nicht leer ist; und
    • ein Identifizierungsinformations-Löschmittel, um eine Identifizierungsinformation über das Klassenverwaltungsobjekt (24a- 24m) aus einer Liste (47) verwiesener Objekte von Klassenverwaltungsobjekten (24a - 24m) zu löschen, welche Klassendaten verwalten, auf die durch zu löschende Klassendaten verwiesen wurde, wenn eine Liste (46) verwiesener Objekte der Klassenverwaltungsobjekte (24a - 24m) nicht leer ist.
  14. Gerät nach Anspruch 1, worin die Schnittstelle (26) für ein öffentliches Fern-Verfahren ferner aufweist:
    • ein Mittel zur Fernauswertung von Klassendaten, um Klassendaten zu verarbeiten, die von einem anderen Objekt (22a - 22n) der Benutzerarbeitseinheitsklasse übertragen wurden.
  15. Gerät nach Anspruch 14, worin das Mittel zur Fernauswertung von Klassendaten ferner aufweist:
    • ein Klassendaten festlegendes Mittel, um die Klassendaten in einer lokalen Klassendatentabelle (41) von Klassenverwaltungsobjekten (24a - 24m) festzulegen.
  16. Gerät nach Anspruch 14, worin das Mittel zur Fernauswertung von Klassendaten ferner aufweist:
    • ein Datenempfangsmittel zum Empfangen von Klassendaten und serialisierter Daten von Objekten, die aus Klassendaten erzeugt wurden; und
    • ein Objektwiederherstellungsmittel zum Wiederherstellen eines Objekts, das aus Klassendaten erzeugt wurde, basierend auf den Klassendaten und den serialisierten Daten.
  17. Gerät nach Anspruch 14, worin das Mittel zur Fernauswertung von Klassendaten ferner aufweist:
    • Klassendaten-Aufrufmittel zum Aufrufen von Klassendaten, auf die durch zu verarbeitende Klassendaten verwiesen wurde, aus der Tabelle (25) gemeinsam genutzter Klassendaten; und
    • ein erstes Klassendaten-Übertragungsmittel zum Übertragen der auszuwertenden Klassendaten und der Klassendaten, auf die durch die auszuwertenden Klassendaten verwiesen wurde, zu einem anderen Objekt (22a - 22n) einer Benutzerarbeitseinheitsklasse.
  18. Gerät nach Anspruch 14, worin das Mittel zur Fernauswertung von Klassendaten aufweist:
    • ein Doppelklassenprüfmittel, um zu prüfen, ob auszuwertende Klassendaten in einer Tabelle (25) gemeinsam genutzter Klassendaten eines Objekts (22a - 22n) einer Ziel-Benutzerarbeitseinheitsklasse existieren oder nicht; und
    • ein zweites Klassendaten-Übertragungsmittel, um basierend auf dem Prüfergebnis auszuwertende Klassendaten zum Objekt (22a - 22n) einer Ziel-Benutzerarbeitseinheitsklasse nach Entfernen von im Objekt (22a - 22n) einer Ziel-Benutzerarbeitseinheitsklasse existierenden Klassendaten zu übertragen.
Anspruch[en]
  1. An information processing apparatus for operating a program formed by class data, the apparatus comprising:
    • agent class storage means (31) for storing an agent class for generating an agent class object which monitors utilization of class data, and
    • agent class object generation means for generating a said agent class object (22a - 22n) based on the agent class, when a process is performed on the class data;
       wherein said agent class object comprises:
    • at least one class management object (24a - 24m) for managing the class data added to the agent class object (22a - 22n);
    • a shared class date table (25) for storing the class data managed by the one or more class management objects (24a - 24m) comprised by said agent class object; and
    • a public remote method interface (26) for performing the process on the class data;
       wherein said public remote method interface (26) comprises:
    • class data addition means for adding a class data to the agent class object (22a - 22n), said class data to be managed by a class management object comprised by said agent class object, said class data representing a function to be processed;
    • class data process means for processing class data representing a function to be processed and stored in said agent class object (22a - 22n); and
    • class data replacing or deletion means for replacing or deleting class data stored in said agent class object (22a - 22n);
       whereby said agent class object monitors utilization of class data to recognise the class data being used while the program is operated, and, in response to a request to replace or to delete class data, if said requested class data is being used, the requested class data is replaced or deleted after use thereof has finished without stopping operation of said program.
  2. The apparatus according to claim 1, wherein

       said agent class object further comprises:
    • a class management object table (23) for storing a correspondence between said class management object (24a - 24m) generated for a request to add the class data and a name assigned when the request to add the class data is issued.
  3. The apparatus according to claim 2, wherein

       said class management object (24a - 24m) comprises:
    • a local class data table (41) for storing class data specific to each class management object (24a - 24m);
    • a deletion flag (42) for storing a request to delete the class data;
    • a replacement class data storage area (43) for storing new class data when a request to replace the class data is issued;
    • a running thread ID list (44) for storing identification information about a thread processing the class data;
    • a class name list (45) for storing a class name corresponding to the class data;
    • a reference object list (46) for storing identification information about a class management object (24a - 24m) which manages class data referenced by the class data; and
    • a referenced object list (47) for storing identification information about a class management object (24a - 24m) which manages class data by which the class data is referenced.
  4. The apparatus according to claim 1 , wherein

       said agent class stores:
    • an access control class for checking access privileges of another agent class object (22a - 22n) in said shared class data table (25).
  5. The apparatus according to claim 1, wherein

       said agent class object comprises:
    • access control object generation means for generating an access control object based on said access control class when access is gained from another agent class object (22a - 22n); and
    • access control object execution means for checking access privileges based on the access control object.
  6. The apparatus according to claim 1 , wherein

       said class data addition means comprises:
    • class management object generation means for generating a class management object (24a - 24m) for managing class data added to the agent class object (22a - 22n);
    • class name registration means for registering a class name of the class data in a class name list (45) in said class management object (24a - 24m);
    • class data writing means for writing the class data in said shared class data table (25); and
    • class management object registration means for registering in said class management object table (23) a name assigned when the request to add the class data is issued.
  7. The apparatus according to claim 6, wherein

       said class data addition means further comprises:
    • shared class data table restoration means for restoring said shared class data table (25) to an original state by deleting class data added to said agent class object (22a - 22n) from said shared class data table (25) when a class name of class data added to said agent class object (22a - 22n) matches a class name of class data registered in said shared class data table (25).
  8. The apparatus according to claim 1 , wherein

       said class data process means comprises:
    • first thread list setting means for setting identification information about a thread processing the class data in a running thread ID list (44) of class management objects (24a - 24m) which manage class data being processed; and
    • second thread list setting means for setting identification information about a thread processing the class data in a running thread ID list (44) of class management objects (24a - 24m) which manage class data referenced by class data being processed.
  9. The apparatus according to claim 8, wherein

       said class data process means comprises:
    • first running thread list check means for checking whether or not identification information about a thread is set in the running thread ID list (44) of class management objects (24a - 24m);
    • deletion flag determination means for determining a setting of a deletion flag (42) of the class management object (24a - 24m); and
    • deletion execution means for deleting class data corresponding to a class name of a class name list (45) in a class management object (24a - 24m) from the shared class data table (25) when the running thread ID list (44) is empty and a deletion flag (42) of the class management object (24a - 24m) is TRUE.
  10. The apparatus according to claim 8, wherein

       said class data process means comprises:
    • second running thread list check means for checking whether or not identification information about a thread is set in the running thread ID list (44) of class management objects (24a - 24m);
    • replacement class data retrieval means for retrieving a replacement class data storage area (43) of the class management object (24a - 24m); and
    • replacement execution means for replacing class data which is to be replaced and is stored in the shared class data table (25) with class data stored in the replacement class data storage area (43) when the running thread ID list (44) is empty and class data of a class management object (24a - 24m) is stored in the replacement class data storage area (43).
  11. The apparatus according to claim 1, wherein

       said class data deletion means comprises:
    • third running thread list check means for checking a running thread ID list (44) of class management objects (24a - 24m) which manage class data to be deleted; and
    • deletion flag setting means for stopping deleting the class data and setting TRUE a deletion flag (42) of the class management object (24a - 24m) when identification information about a thread is set in the running thread ID list (44).
  12. The apparatus according to claim 1, wherein

       said class data replacement means comprises:
    • fourth running thread list check means for checking a running thread ID list (44) of class management objects (24a - 24m) which manage class data to be replaced;
    • replacement data setting means for stopping replacing the class data and setting new class data in a replacement class data storage area (43) of the class management object (24a - 24m) when identification information about a thread is set in the running thread ID list (44).
  13. The apparatus according to claim 11 or 12, further comprising:
    • error notification means for issuing an error notification when a referenced object list (47) of the class management objects (24a - 24m) is not empty; and
    • identification information deletion means for deleting identification information about the class management object (24a - 24m) from a referenced object list (47) of class management objects (24a - 24m) which manage class data referenced by class data to be deleted when a reference object list (46) of the class management objects (24a - 24m) is not empty.
  14. The apparatus according to claim 1 , wherein

       said public remote method interface (26) further comprises:
    • class data remote evaluation means for processing class data transmitted from another agent class object (22a - 22n).
  15. The apparatus according to claim 14, wherein

       said class data remote evaluation means further comprises:
    • class data setting means for setting the class data in a local class data table (41) of class management objects (24a - 24m).
  16. The apparatus according to claim 14, wherein

       said class data remote evaluation means further comprises:
    • data receiving means for receiving class data and serialized data of objects generated from the class data; and
    • object restoration means for restoring an object generated from the class data based on the class data and the serialized data.
  17. The apparatus according to claim 14, wherein

       said class data remote evaluation means further comprises:
    • class data invoking means for invoking class data referenced by class data to be processed from the shared class data table (25); and
    • first class data transmission means for transmitting the class data to be evaluated and class data referenced by the class data to be evaluated to another agent class object (22a - 22n).
  18. The apparatus according to claim 14, wherein

       said class data remote evaluation means comprises:
    • double class check means for checking whether or not class data to be evaluated exist in a shared class data table (25) of a destination agent class object. (22a - 22n); and
    • second class data transmission means for transmitting, based on the check result, class data to be evaluated to the destination agent class object (22a - 22n) after removing class data existing in the destination agent class object (22a - 22n).
Anspruch[fr]
  1. Un appareil de traitement d'information pour exécuter un programme formé par des données de classe, l'appareil comprenant :
    • des moyens de stockage de classe d'agent (31) pour stocker une classe d'agent pour générer un objet de classe d'agent qui contrôle l'utilisation de données de classe, et
    • des moyens de génération d'objet de classe d'agent pour générer un objet de classe d'agent (22a - 22n) précité, basé sur la classe d'agent, lorsqu'un processus est effectué sur les données de classe;
       dans lequel l'objet de classe d'agent comprend :
    • au moins un objet de gestion de classe (24a - 24m) pour gérer les données de classe ajoutées à l'objet de classe d'agent (22a - 22n);
    • une table de données de classe partagée (25) pour stocker les données de classe gérées par le ou les objets de gestion de classe (24a - 24m) formés par l'objet de classe d'agent; et
    • une interface de méthode distante publique (26) pour accomplir le processus sur les données de classe;
       dans lequel l'interface de méthode distante publique (26) comprend :
    • des moyens d'ajout de données de classe pour ajouter des données de classe à l'objet de classe d'agent (22a - 22n), ces données de classe devant être gérées par un objet de gestion de classe formé par l'objet de classe d'agent, ces données de classe représentant une fonction à traiter;
    • des moyens de traitement de données de classe pour traiter des données de classe représentant une fonction à traiter et stockées dans l'objet de classe d'agent (22a - 22n); et
    • des moyens de remplacement ou de suppression de données de classe pour remplacer ou supprimer des données de classe stockées dans l'objet de classe d'agent (22a - 22n);
    • grâce à quoi l'objet de classe d'agent contrôle l'utilisation de données de classe pour reconnaître les données de classe qui sont en cours d'utilisation pendant que le programme est exécuté, et, en réponse à une demande de remplacement ou de suppression de données de classe, si les données de classe demandées sont en cours d'utilisation, les données de classe demandées sont remplacées ou supprimées après que leur utilisation s'est terminée, sans arrêter l'exécution du programme.
  2. L'appareil selon la revendication 1, dans lequel

       l'objet de classe d'agent comprend en outre :
    • une table d'objet de gestion de classe (23) pour stocker une correspondance entre l'objet de gestion de classe (24a - 24m) généré pour une demande d'ajout des données de classe, et un nom assigné lorsque la demande d'ajout des données de classe est émise.
  3. L'appareil selon la revendication 2, dans lequel

       l'objet de gestion de classe (24a - 24m) comprend :
    • une table de données de classe locale (41) pour stocker des données de classe spécifiques à chaque objet de gestion de classe (24a - 24m);
    • un drapeau de suppression (42) pour stocker une demande de suppression des données de classe;
    • une zone de stockage de données de classe de remplacement (43) pour stocker de nouvelles données de classe lorsqu'une demande de remplacement des données de classe est émise;
    • une liste tournante d'identifications de fil (44) pour stocker une information d'identification concernant un traitement de fil des données de classe;
    • une liste de noms de classe (45) pour stocker un nombre de classe correspondant aux données de classe;
    • une liste d'objets de référence (46) pour stocker une information d'identification concernant un objet de gestion de classe (24a - 24m) qui gère des données de classe référencées par les données de classe; et
    • une liste d'objets référencés (47) pour stocker une information d'identification concernant un objet de gestion de classe (24a - 24m) qui gère des données de classe par lesquelles les données de classe sont référencées.
  4. L'appareil selon la revendication 1, dans lequel

       la classe d'agent stocke :
    • une classe de commande d'accès pour contrôler des privilèges d'accès d'un autre objet de classe d'agent (22a - 22n) dans la table de données de classe partagée (25).
  5. L'appareil selon la revendication 1, dans lequel

       l'objet de classe d'agent comprend :
    • des moyens de génération d'objet de commande d'accès pour générer un objet de commande d'accès basé sur la classe de commande d'accès lorsque l'accès est obtenu à partir d'un autre objet de classe d'agent (22a - 22n); et
    • des moyens d'exécution d'objet de commande d'accès pour contrôler les privilèges d'accès basés sur l'objet de commande d'accès.
  6. L'appareil selon la revendication 1, dans lequel

       les moyens d'ajout de données de classe comprennent :
    • des moyens de génération d'objet de gestion de classe pour générer un objet de gestion de classe (24a - 24m) pour gérer des données de classe ajoutées à l'objet de classe d'agent (22a - 22n);
    • des moyens d'enregistrement de nom de classe pour enregistrer un nom de classe des données de classe dans une liste de noms de classe (45) dans l'objet de gestion de classe (24a - 24m);
    • des moyens d'écriture de données de classe pour écrire les données de classe dans la table de données de classe partagée (25); et
    • des moyens d'enregistrement d'objet de gestion de classe pour enregistrer dans la table d'objet de gestion de classe (23) un nom assigné lorsque la demande d'ajout des données de classe est émise.
  7. L'appareil selon la revendication 6, dans lequel

       les moyens d'ajout de données de classe comprennent en outre:
    • des moyens de restauration de table de données de classe partagée pour restaurer la table de données de classe partagée (25) dans un état original en supprimant des données de classe ajoutées à l'objet de classe d'agent (22a - 22n) à partir de la table de données de classe partagée (25), lorsqu'un nom de classe de données de classe ajoutées à l'objet de classe d'agent (22a - 22n) concorde avec un nom de classe de données de classe enregistrées dans la table de données de classe partagée (25).
  8. L'appareil selon la revendication 1, dans lequel

       les moyens de traitement de données de classe comprennent :
    • des premiers moyens de fixation de liste de fils pour fixer une information d'identification concernant un fil traitant les données de classe, dans une liste tournante d'identifications de fil (44) d'objets de gestion de classe (24a - 24m) qui gèrent des données de classe en cours de traitement; et
    • des seconds moyens de fixation de liste de fils pour fixer une information d'identification concernant un fil traitant les données de classe dans une liste tournante d'identifications de fil (44) d'objets de gestion de classe (24a - 24m) qui gèrent des données de classe référencées par des données de classe en cours de traitement.
  9. L'appareil selon la revendication 8, dans lequel

       les moyens de traitement de données de classe comprennent :
    • des premiers moyens de contrôle de liste tournante de fils pour contrôler si une information d'identification concernant un fil est fixée ou non dans la liste tournante d'identifications de fil (44) d'objets de gestion de classe (24a - 24m);
    • des moyens de détermination de drapeau de suppression pour déterminer une fixation d'un drapeau de suppression (42) de l'objet de gestion de classe (24a - 24m); et
    • des moyens d'exécution de suppression pour supprimer des données de classe correspondant à un nom de classe d'une liste de noms de classe (45) dans un objet de gestion de classe (24a - 24m), à partir de la table de données de classe partagée (25), lorsque la liste tournante d'identifications de fil (44) est vide, et un drapeau de suppression (42) de l'objet de gestion de classe (24a - 24m) est à l'état VRAI.
  10. L'appareil selon la revendication 8, dans lequel

       les moyens de traitement de données de classe comprennent :
    • des seconds moyens de contrôle de liste tournante de fils pour contrôler si une information d'identification concernant un fil est fixée ou non dans la liste tournante d'identifications de fil (44) d'objets de gestion de classe (24a - 24m);
    • des moyens d'obtention de données de classe de remplacement pour obtenir une zone de stockage de données de classe de remplacement (43) de l'objet de gestion de classe (24a - 24m); et
    • des moyens d'exécution de remplacement pour remplacer des données de classe qui doivent être remplacées et sont stockées dans la table de données de classe partagée (25), par des données de classe stockées dans la zone de stockage de données de classe de remplacement (43), lorsque la liste tournante d'identifications de fil (44) est vide, et des données de classe d'un objet de gestion de classe (24a - 24m) sont stockées dans la zone de stockage de données de classe de remplacement (43).
  11. L'appareil selon la revendication 1, dans lequel

       les moyens de suppression de données de classe comprennent:
    • des troisièmes moyens de contrôle de liste tournante de fils pour contrôler une liste tournante d'identifications de fil (44) d'objets de gestion de classe (24a - 24m) qui gèrent des données de classe à supprimer; et
    • des moyens de fixation de drapeau de suppression pour arrêter la suppression des données de classe et placer à l'état VRAI un drapeau de suppression (42) de l'objet de gestion de classe (24a - 24m) lorsqu'une information d'identification concernant un fil est fixée dans la liste tournante d'identifications de fil (44).
  12. L'appareil selon la revendication 1, dans lequel

       les moyens de remplacement de données de classe comprennent :
    • des quatrièmes moyens de contrôle de liste tournante de fils pour contrôler une liste tournante d'identifications de fil (44) d'objets de gestion de classe (24a - 24m) qui gèrent des données de classe à remplacer;
    • des moyens de fixation de données de données de remplacement pour arrêter le remplacement des données de classe et fixer de nouvelles données de classe dans une zone de stockage de données de classe de remplacement (43) de l'objet de gestion de classe (24a - 24m) lorsqu'une information d'identification concernant un fil est fixée dans la liste tournante d'identifications de fils (44).
  13. L'appareil selon la revendication 11 ou 12, comprenant en outre :
    • des moyens de notification d'erreur pour émettre une notification d'erreur lorsqu'une liste d'objets référencés (47) des objets de gestion de classe (24a - 24m) n'est pas vide; et
    • des moyens de suppression d'information d'identification pour supprimer une information d'identification concernant l'objet de gestion de classe (24a - 24m) dans une liste d'objets référencés (47) d'objets de gestion de classe (24a - 24m) qui gèrent des données de classe référencées par des données de classe à supprimer lorsqu'une liste d'objets de référence (46) des objets de gestion de classe (24a - 24m) n'est pas vide.
  14. L'appareil selon la revendication 1, dans lequel

       l'interface de méthode distante publique (26) comprend en outre :
    • des moyens d'évaluation à distance de données de classe pour traiter des données de classe émises à partir d'un autre objet de classe d'agent (22a - 22n).
  15. L'appareil selon la revendication 14, dans lequel

       les moyens d'évaluation à distance de données de classe comprennent en outre :
    • des moyens de fixation de données de classe pour fixer les données de classe dans une table de données de classe locale (41) d'objets de gestion de classe (24a - 24m).
  16. L'appareil selon la revendication 14, dans lequel

       les moyens d'évaluation à distance de données de classe comprennent en outre :
    • des moyens de réception de données pour recevoir des données de classe et des données sérialisées d'objets générés à partir des données de classe; et
    • des moyens de restauration d'objet pour restaurer un objet généré à partir des données de classe sur la base des données de classe et des données sérialisées.
  17. L'appareil selon la revendication 14, dans lequel

       les moyens d'évaluation à distance de données de classe comprennent en outre :
    • des moyens d'appel de données de classe pour appeler des données de classe référencées par des données de classe à traiter, provenant de la table de données de classe partagée (25); et
    • des premiers moyens de transmission de données de classe pour transmettre vers un autre objet de classe d'agent (22a - 22n) les données de classe à évaluer et les données de classe référencées par les données de classe à évaluer.
  18. L'appareil selon la revendication 14, dans lequel

       les moyens d'évaluation à distance de données de classe comprennent en outre :
    • des moyens de contrôle de classe en double pour contrôler si des données de classe à évaluer existent ou non dans une table de données de classe partagée (25) d'un objet de classe d'agent de destination (22a - 22n); et
    • des seconds moyens de transmission de données de classe pour transmettre à l'objet de classe d'agent de destination (22a - 22n), sur la base du résultat de contrôle, des données de classe à évaluer, après la suppression de données de classe qui existent dans l'objet de classe d'agent de destination (22a - 22n).






IPC
A Täglicher Lebensbedarf
B Arbeitsverfahren; Transportieren
C Chemie; Hüttenwesen
D Textilien; Papier
E Bauwesen; Erdbohren; Bergbau
F Maschinenbau; Beleuchtung; Heizung; Waffen; Sprengen
G Physik
H Elektrotechnik

Anmelder
Datum

Patentrecherche

Patent Zeichnungen (PDF)

Copyright © 2008 Patent-De Alle Rechte vorbehalten. eMail: info@patent-de.com