JP2009206779A - Indirect communication system, communication method and communication program - Google Patents

Abstract

<P>PROBLEM TO BE SOLVED: To provide an indirect communication system by which a transmitting terminal enables to select a receiving terminal, and also to comprehend the receiving terminal. <P>SOLUTION: The indirect communication system is constituted so that a matching condition is included in a uTuple (commandActual) for writing, a matching object is included in a uTuple (CommandFormal) for reading, a communication terminal which registers the uTuple for reading matched to the uTuple for writing is notified of the uTuple (CommandActual) for writing, and a communication terminal to be the transmitting terminal which registers the uTuple (CommandActual) for writing is notified of the uTuple (CommandFormal) for reading. <P>COPYRIGHT: (C)2009,JPO&INPIT

Description

  The present invention provides a communication platform for realizing various services such as a ubiquitous service in which a plurality of programs operating on a sensor / actuator terminal and a server terminal cooperate with each other in various networks such as a ubiquitous network. The present invention relates to an indirect communication system, a communication method, and a communication program that are suitable for use in communication.

  To streamline the development and operation of services provided on networks using multiple terminals, such as ubiquitous services, there is a communication platform that can flexibly respond to the addition / change / deletion of programs / terminals that make up services. is necessary. TupleSpace (see Non-Patent Document 1) is a candidate for a communication model that satisfies the requirements of this communication platform. TupleSpace is a communication model similar to a bulletin board, and a program logically shares a single space, and programs communicate indirectly by reading and writing data to the shared space.

  In communication using TupleSpace, TupleSpace programs that run on each terminal or server read and write Tuple (tuple; Key-Value Pair = key-value pair) to TupleSpace (or TupleStorage). Communicate indirectly. Specifically, communication occurs by matching processing between the sender's writing Tuple (Actual) and the receiver's reading Tuple (Forma1). The sender's writing Tuple (Actua1) includes the matching target, and the receiver's reading Tuple (Formal) includes the matching condition, and the writing Tuple (Actual) that matches the Reading Tuple (Formal) is the reading Tuple. Notification is sent to the recipient who registered (Formal). That is, the receiving terminal that writes the reading Tuple (Forma1) specifies the condition of the transmitting terminal that writes the writing Tuple (Actual).

  FIG. 1 shows a specific example of the TupleSpace communication model. In the communication model shown in FIG. 1, the server terminal 1, the sensor terminal 2, and the actuator terminal 3 are connected to the ubiquitous network 4 and are executed on the terminals 1 to 3, respectively. Further, the storage means such as a memory in each terminal 1 to 3 or another terminal (not shown) and the ubiquitous network 4 as a communication means are used for logic between the programs 11, 21, and 31 of each terminal 1 to 3. TupleSpace 5 which is one space (memory space) shared in common is configured. The programs communicate indirectly by reading and writing data to and from TupleSpace 5, which is this shared space.

  In the example shown in this figure, for example, a writing Tuple (Actual) 61 registered by the program 21 of the sensor terminal 2 in the TupleSpace 5 and a reading Tuple (Formal) 62 registered by the program 11 of the server terminal 1 in the TupleSpace 5 are used. Are matched, the writing Tuple (Actual) 61 is read by the program 11 of the server terminal 1. Alternatively, when the reading Tuple (Formal) 63 registered in the TupleSpace 5 by the program 31 of the actuator terminal 3 and the writing Tuple (Actual) 64 registered in the TupleSpace 5 by the program 11 of the server terminal 1 are matched, the Tuple for writing ( Actual) 64 is read by the program 31 of the actuator terminal 30. The Tuple legend is indicated by reference numeral 60.

  In the communication model of TulpleSpace, it is possible to communicate with any two terminals via TulpleSpace, and these communication are all independent. For example, the programs of the sensor terminal and the actuator terminal can communicate with each other via TulpleSpace, and the programs of the same terminal can communicate with each other via TulpleSpace. Further, communication between the program of the sensor terminal and the server terminal and communication between the program of the server terminal and the actuator terminal are performed independently. As shown in FIG. 1, the communication model of TulpleSpace is not limited to a mode in which programs between terminals such as sensors, actuators, and servers communicate with each other independently. For example, a server terminal is used as a management server. It is also possible to take a form in which each terminal communicates via a program executed on the management server. In this case, for example, the communication is performed by the server terminal program mediating communication between the sensor terminal program and the actuator terminal program. The form can be determined by the contents of each program.

  The communication system using the TulpleSpace communication model has the following two features.

(Characteristic 1) Since data (Tuple) is transmitted and received through a permanent space (TupleSpace), it is not necessary for the program of the communication partner to operate simultaneously.

(Feature 2) Since the destination is determined by matching the data (Tuple) contents, it is not necessary to know the address of the communication partner in advance.
D. Gelemter, "Generative communication in linda," ACM Trans. Prog. Lang. Syst., Vol. 7, no. 1, pp. 80-112, Jan. l985.

  TupleSpace's communication model weakens the connection between programs in terms of time (feature 1) and relationship (feature 2), and flexibly supports the addition / change / deletion of programs / terminals that make up the service. It has a foundation as a possible communication platform. However, the original communication model has the following two problems to be solved.

(Problem 1) The transmitting terminal cannot select the receiving terminal. For this reason, there is no particular problem in communication in which the sending terminal does not need to specify the receiving terminal condition (ie, the receiving terminal needs to specify the sending terminal condition) as in the case of sending and receiving sensor events. In communication where the transmitting terminal needs to specify the receiving terminal condition (that is, the receiving terminal does not need to specify the transmitting terminal condition), data is not always transmitted to the receiving terminal intended by the transmitting terminal. There is no problem.

(Problem 2) The transmitting terminal cannot grasp the receiving terminal. For this reason, there is a problem that it is impossible to avoid sending data wastefully even though there is no receiving terminal that actually receives the data. Further, there is a problem that it is impossible to track which receiving terminal has actually received the transmitted data.

  The present invention has been made in view of the above circumstances, and is intended to improve convenience in indirect communication. The transmitting terminal can select the receiving terminal, and the transmitting terminal can grasp the receiving terminal. It is an object to provide an indirect communication system, a communication method, and a communication program.

  In order to solve the above-mentioned problem, the invention according to claim 1 is a communication means for connecting a plurality of terminals, and a writing tuple or a read which is connected by the communication means and becomes data to be communicated. One or a plurality of communication terminals that register at least one of the tuples as a transmission terminal or a reception terminal in a predetermined storage unit, and information indicating a matching target or a matching condition in each tuple registered in the predetermined storage unit It is a system that performs indirect communication by including them, matching conditions to the writing tuple registered by the communication terminal serving as the transmitting terminal, and matching targets to the reading tuple registered by the communication terminal serving as the receiving terminal To the communication terminal that is the receiving terminal that has registered the reading tuple that matches the writing tuple. And notifies the for-inclusive can tuple.

  According to a second aspect of the present invention, communication means for connecting a plurality of terminals, and at least one of a writing tuple and a reading tuple which are connected by the communication means and become data to be communicated are transmitted. One or a plurality of communication terminals registered in a predetermined storage means as a terminal or a receiving terminal, and information indicating a matching target or a matching condition is included in each tuple registered in the predetermined storage means, and they are matched This is a system that performs indirect communication, including a matching target in a writing tuple registered by a communication terminal serving as a transmitting terminal, a matching condition included in a reading tuple registered by a communication terminal serving as a receiving terminal, and a matching condition A sending terminal that has registered a tuple for writing including a matching target that matches the tuple for reading Notifying the communication terminal of the reading tuple, or including a matching target in the writing tuple registered by the communication terminal serving as the transmitting terminal, and the matching target included in the reading tuple registered by the communication terminal serving as the receiving terminal, A reading tuple including a matching target that matches a writing tuple including a matching condition is notified to a communication terminal serving as a transmitting terminal in which the writing tuple is registered.

  The invention according to claim 3 notifies the communication terminal as a receiving terminal that has registered the read tuple, or registered the matched read tuple, or all of the matched tuples for writing. A flag that specifies whether to write tuples to all or one of the communication terminals as a receiving terminal, and after that notification, the matched write tuple or the matched read tuple is deleted or not deleted And a flag for designating whether the flag is included in the read tuple or the write tuple.

  The invention according to claim 4 provides a flag for designating the presence or absence of notification of the reading tuple or the writing tuple to the communication terminal as the transmitting terminal or the communication terminal as the receiving terminal. It is included in the tuple for writing.

  According to a fifth aspect of the present invention, communication means for connecting a plurality of terminals, and at least one of a writing tuple and a reading tuple which are connected by the communication means and become data to be communicated are transmitted. Using one or a plurality of communication terminals registered in a predetermined storage means as a terminal or a receiving terminal, each tuple registered in the predetermined storage means includes information indicating a matching target or a matching condition and matches them. The indirect communication method includes a matching condition in a writing tuple registered by a communication terminal serving as a transmitting terminal, and a matching target in a reading tuple registered by a communication terminal serving as a receiving terminal. Notify the writing tuple to the communication terminal that is the receiving terminal that has registered the reading tuple that matches the tuple. The features.

  According to a sixth aspect of the present invention, a communication means for connecting a plurality of terminals, and at least one of a writing tuple or a reading tuple that is connected by the communication means and serves as data to be communicated is transmitted. Using one or a plurality of communication terminals registered in a predetermined storage means as a terminal or a receiving terminal, each tuple registered in the predetermined storage means includes information indicating a matching target or a matching condition and matches them. In this case, the indirect communication method includes a matching target in the writing tuple registered by the communication terminal serving as the transmitting terminal, and a matching condition in the reading tuple registered by the communication terminal serving as the receiving terminal. A communication terminal that registers a write tuple that contains a matching target that matches the read tuple Either notify the terminal of the tuple for reading, or include matching conditions in the writing tuple registered by the communication terminal serving as the transmitting terminal, and include the matching target in the reading tuple registered by the communication terminal serving as the receiving terminal, and matching A reading tuple including a matching target that matches a writing tuple including a condition is notified to a communication terminal serving as a transmitting terminal in which the writing tuple is registered.

  The invention according to claim 7 notifies all or one of the matched tuples for writing to the communication terminal as a receiving terminal in which the tuple for reading is registered, or registers the matched tuple for reading. A flag that specifies whether to write tuples to all or one of the communication terminals as a receiving terminal, and after that notification, the matched write tuple or the matched read tuple is deleted or not deleted And a flag for designating whether the flag is included in the read tuple or the write tuple.

  The invention according to claim 8 is a flag that specifies the presence or absence of notification of the reading tuple or the writing tuple to the communication terminal as the transmitting terminal or the communication terminal as the receiving terminal. It is included in the tuple for writing.

  The invention according to claim 9 is a communication means for connecting a plurality of terminals, and is connected by the communication means, and transmits at least one of a writing tuple or a reading tuple as data to be communicated. Using one or a plurality of communication terminals registered in a predetermined storage means as a terminal or a receiving terminal, each tuple registered in the predetermined storage means includes information indicating a matching target or a matching condition and matches them. Thus, when performing indirect communication, matching conditions are included in the writing tuple registered by the communication terminal serving as the transmitting terminal, and the matching target is included in the reading tuple registered by the communication terminal serving as the receiving terminal. Processing for notifying the communication terminal as a receiving terminal that has registered the matching read tuple, of the write tuple Characterized in that it comprises a description for executing with a computer.

  According to a tenth aspect of the present invention, communication means for connecting a plurality of terminals and at least one of a writing tuple or a reading tuple that is connected by the communication means and serves as data to be communicated is transmitted. Using one or a plurality of communication terminals registered in a predetermined storage means as a terminal or a receiving terminal, each tuple registered in the predetermined storage means includes information indicating a matching target or a matching condition and matches them. When performing indirect communication, a matching tuple is included in the writing tuple registered by the communication terminal serving as the transmitting terminal, and a matching tuple is included in the reading tuple registered by the communication terminal serving as the receiving terminal. Communication terminal that becomes a transmitting terminal that registers a tuple for writing including a matching target that matches the tuple Notify the reading tuple, or include the matching condition in the writing tuple registered by the communication terminal serving as the transmitting terminal, the matching target included in the reading tuple registered by the communication terminal serving as the receiving terminal, and the matching condition Including a description for executing, using a computer, processing for notifying a communication terminal serving as a transmission terminal that has registered the write tuple of a read tuple that includes a matching target that matches the write tuple. To do.

  The invention according to claim 11 notifies the communication terminal as a receiving terminal that has registered the read tuple, or registered the matched read tuple, or all of the matched tuples for writing. A flag that specifies whether to write tuples to all or one of the communication terminals as a receiving terminal, and after that notification, the matched write tuple or the matched read tuple is deleted or not deleted It includes a description for executing, using a computer, processing for including a flag for designating the flag in the reading tuple or the writing tuple.

  The invention according to claim 12 is characterized in that a flag that specifies the presence or absence of notification of the reading tuple or the writing tuple to the communication terminal as the transmission terminal or the communication terminal as the reception terminal It includes a description for executing processing to be included in the writing tuple using a computer.

  In the present invention, a matching tuple is included in the writing tuple registered by the communication terminal serving as the transmitting terminal, and the reading tuple matching the writing tuple is included in the reading tuple registered by the communication terminal serving as the receiving terminal. The writing tuple is notified to the communication terminal that is the receiving terminal that has registered. That is, for example, the matching condition is included in the writing tuple (CommandActual) of the transmitting terminal, the matching target is included in the reading tuple (CommandFormal) of the receiving terminal, and the reading tuple (CommandFormal) that matches the writing tuple (CommandActual) is registered. The receiving tuple (CommandActual) is notified to the receiving terminal. Therefore, the transmitting terminal can select the receiving terminal. As a result, it is necessary for the transmitting terminal to specify the receiving terminal condition (that is, the receiving terminal does not need to specify the transmitting terminal condition) like transmission / reception of an actuator command. Can be sent.

  Also, in the present invention, the tuple for writing registered by the communication terminal serving as the transmitting terminal includes the matching target, the reading tuple registered by the communication terminal serving as the receiving terminal includes the matching condition, and the reading tuple including the matching condition. To the communication terminal serving as the transmitting terminal that has registered the writing tuple including the matching target that matches the matching tuple, the matching condition in the writing tuple registered by the communication terminal serving as the transmitting terminal, and the receiving terminal The matching tuple is included in the reading tuple registered by the communication terminal, and the reading tuple including the matching target matching the writing tuple including the matching condition is notified to the communication terminal serving as the transmitting terminal in which the writing tuple is registered. I tried to do it. That is, for example, the reading tuple (EventFormal) is notified to the transmitting terminal that registered the writing tuple (EventActual) that matches the reading tuple (EventFormal), or matches the writing tuple (CommandActual). The reading tuple (CommandFormal) is notified to the transmitting terminal that has registered the writing tuple (CommandActual). As a result, the transmitting terminal can grasp the receiving terminal. As a result, it is possible to avoid sending data wastefully even though there is no receiving terminal that actually receives the data. In addition, it is possible to track which receiving terminal has actually received the transmitted data.

  The tuple space (referred to as “uTupleSpace”) in the present invention is an extension of the communication model of the tuple space TupleSpace described with reference to FIG. 1 and is led by a receiving terminal in which an existing receiving terminal selects a transmitting terminal. In addition to the above communication (Event type communication; event type communication), the transmission terminal initiated communication (Command type communication; command type communication) in which the transmitting terminal selects the receiving terminal is newly realized. In this embodiment, in Event type communication and Command type communication, in addition to forward communication (Actual-to-Formal communication) in which the receiving terminal grasps the transmitting terminal, the transmitting terminal Realize reverse communication (Formal-to-Actual communication) to grasp the receiving terminal.

  In this embodiment, a Tuple that is read from and written to uTupleSpace is represented as “uTuple”. This uTuple can be divided into two types, “Actual” which is uTuple that the application program writes to the uTupleSpace as data, and “Formal” which is uTuple for reading out the uTuple (Actual) written there from the uTupleSpace. As described above, in this embodiment, in addition to existing reception terminal-driven communication (Event type communication), transmission terminal-driven communication (Command type communication) is newly realized. In the present embodiment, two types of uTuple in Event type communication are expressed as “EventActual” (Event type writing uTuple; uTuple including matching target) and “EventdFormal” (Event type reading uTuple; uTuple including matching condition). The two types of uTuple in Command type communication are represented as “CommandActual” (uTuple for command type writing; uTuple including matching condition) and “CommandFormal” (uTuple for command type reading; uTuple including matching target).

  The tuple space (uTupleSpace) is a conceptual shared memory (that is, storage means), and this shared memory is distributed in, for example, a plurality of terminals, and includes information representing matching targets or matching conditions in this uTupleSpace. The data (EventActual or CommandActual) as uTuple is written (or registered or transmitted), and also matches the data (EventdFormal or CommandFormal) that contains the matching condition or matching target information as uTuple from this uTupleSpace By reading (or receiving or notifying) data (EventActual or CommandActual), communication is performed between application programs (hereinafter referred to as programs) for uTupleSpace communication.

  FIG. 2 shows a communication model of uTupleSpace according to the embodiment of the present invention. As described above, programs communicate with each other indirectly by reading and writing uTuple (Key-Value Pair) to uTupleSpace (or uTupleStorage). FIG. 2 schematically shows a communication model of the present embodiment, and a plurality of terminals 10 to 30 are usually connected to a communication system that realizes this communication model. Also, there are a plurality of uTuples existing in uTupleSpace in addition to those shown in the figure. The uTuple legend is indicated by reference numeral 70.

  In the communication model shown in FIG. 2, the server terminal 10, the sensor terminal 20, and the actuator terminal 30 are connected to the ubiquitous network 40, and programs 101, 201, and 301 are executed on the terminals 10 to 30, respectively. Further, the storage means such as a memory in each terminal 10-30 or other terminal not shown in the figure and the ubiquitous network 40 as the communication means, the logic between the programs 101, 201, 301, etc. of each terminal 10-30. The uTupleSpace 50, which is one space (memory space) shared in common, is configured. The programs communicate indirectly by reading and writing data from and to the uTupleSpace 50, which is this shared space.

  In the example shown in this figure, for example, the writing uTuple (EventActual) 71 to be the matching target registered by the program 201 of the sensor terminal 20 in the uTupleSpace 50 and the reading uTuple (the matching condition registered by the program 101 of the server terminal 10 in the uTupleSpace 50) (EventFormal) 72 is matched, the writing uTuple (EventActual) 71 is read by the program 101 of the server terminal 10 (that is, the writing uTuple (EventActual) 71 is notified to the server terminal 10) and the reading uTuple (EventFormal) 72 is read by the program 201 of the sensor terminal 20 (that is, the reading uTuple (EventFormal) 72 is notified to the sensor terminal 20).

  Also, the matching uTuple (CommandFormal) 73 for reading registered in the uTupleSpace 50 by the program 301 of the actuator terminal 30 and the writing uTuple (CommnadActual) 74 for matching that the program 101 of the server terminal 10 registered in the uTupleSpace 50 are matched. In this case, the writing uTuple (CommandActual) 74 is read by the program 301 of the actuator terminal 30 (that is, the writing uTuple (CommandActual) 74 is notified to the actuator terminal 30), and the reading uTuple (CommandFormal) 73 is It is read by the program 101 of the terminal 10 (that is, the reading uTuple (CommandFormal) 73 is notified to the server terminal 10).

  In the communication model of uTulpleSpace, it is possible to communicate with any two terminals through the uTulpleSpace 50, and these communications are all independent. For example, the programs 201 and 301 of the sensor terminal 20 and the actuator terminal 30 can communicate with each other via the uTulpleSpace 50, and programs on the same terminal can also communicate with each other via the uTulpleSpace 50. Communication between the programs of the sensor terminal 20 and the server terminal 10 and communication between the programs of the server terminal 10 and the actuator terminal 20 are performed independently. As shown in FIG. 2, the communication model of the TulpleSpace 50 includes a mode in which programs between terminals such as sensors, actuators, and servers communicate with each other independently. For example, a server terminal is used as a management server. It is also possible to take a form in which each terminal communicates via a program executed on the management server. In this case, for example, the communication is performed by the server terminal program mediating communication between the sensor terminal program and the actuator terminal program. The form can be determined by the contents of each program.

  FIG. 3 shows a format of a portion characterized by each uTuple shown in FIG. 2 in the present embodiment. The uTuple of the present embodiment includes a writing terminal uTuple (EventActual) 71 and a receiving terminal reading uTuple (EventFormal) 72 in Event type communication, a writing terminal uTuple (CommandActual) 74 in Command type communication, and There are four types in total: uTuple (CommandFormal) 73 for reading out the receiving terminal. In both event type communication and command type communication, communication occurs by matching processing between the writing uTuple (Actual) 71 or 74 of the transmitting terminal and the reading uTuple (Formal) 72 or 73 of the receiving terminal.

  However, in Event type communication, a matching condition is included in the uTuple (EventActual) 71 for writing of the transmitting terminal (for example, the sensor terminal 20), and a matching condition is included in the reading uTuple (EventFormal) 72 of the receiving terminal (for example, the server terminal 10). A writing uTuple (EventActual) 71 that matches the reading uTuple (EventFormal) 72 is notified to the receiving terminal (for example, the sensor terminal 20) that has registered the reading uTuple (EventFormal) 72 (Actual-to-Formal communication). . On the other hand, in the command type communication, the matching condition is included in the writing uTuple (CommandActual) 74 of the transmitting terminal (for example, the server terminal 10), and the matching target is included in the reading uTuple (CommandFormal) 73 of the receiving terminal (for example, the actuator terminal 30). Then, the uTuple (CommandActual) 74 for writing is notified to the receiving terminal (for example, the actuator terminal 30) that has registered the uTuple (CommandFormal) 74 for reading that matches the uTuple (CommandActual) 73 for writing (Actual-to-Formal communication).

  At the same time, in the event type communication, the reading uTuple (EventFormal) 72 is registered to the transmitting terminal (for example, the sensor terminal 20) that registers the writing uTuple (EventActual) 71 that matches the reading uTuple (EventFormal) 72. Notified (Formal-to-Actual communication). Further, in the command type communication, the reading uTuple (CommandFormal) 73 that matches the writing uTuple (CommandActual) 74 is notified to the transmitting terminal (for example, the server terminal 10) that has registered the writing uTuple (CommandActual) 74 ( Formal-to-actual communication).

  Each uTuple 71 to 74 shown in FIG. 3 is composed of one or a plurality of fields including a pair of a key and a value (character string) corresponding to the key. Keys included in uTuple (EventActual) 71 for writing of the transmitting terminal in Event type communication are “date”, “position”, “address”, “subject”, “type”, and “body”. “Date” is a key representing “time stamp information”, and is associated with a value representing time information. “Position” is a key representing position information, and is associated with a value representing information regarding the position of the transmission terminal. “Address” is a key representing address information, and is associated with a value representing the address of the transmitting terminal. “Subject” is a key indicating the type information of the sensor / actuator, and is associated with a value indicating the type of the terminal of the transmission terminal. “Type” is a key representing what kind of command to the actuator or what kind of event is from the sensor, and values representing these are associated with each other. “Body” is a key representing “parameter” (or data) such as sensor output, and is associated with a set of arbitrary fields defined between applications. The value set in this “body” is transmitted data.

  Keys included in the reading uTuple (EventFormal) 72 of the receiving terminal in Event type communication are “date_range”, “position_range”, “address_range”, “subject”, and “type”. “Date_range” is a key representing “time stamp information” representing a read condition, and is associated with a value representing information representing a time range. “Position_range” is a key that represents position information that represents a read condition, and is associated with a value that represents information about the range of the position of the transmitting terminal. “Address_range” is a key representing address information representing a read condition, and is associated with a value representing a range of addresses of the transmitting terminal. “Subject” is a key indicating the type information of the sensor / actuator, and is associated with a value indicating the type of the transmission terminal. “Type” is a key representing what kind of command to the actuator or what kind of event is from the sensor, and values representing these are associated with each other.

  Keys included in the uTuple (CommandActual) 74 for writing of the transmitting terminal in Command type communication are “date_range”, “position_range”, “address_range”, “subject”, “type”, and “body”. In addition, the keys included in the uTuple (CommandFormal) 73 for reading of the receiving terminal in the command type communication are “date”, “position”, “address”, “subject”, and “type”. The value associated with the contents of each key is the information of the transmitting terminal (that is, the terminal that registered EventActual) in Event type communication, while the information of the receiving terminal (that is, the terminal that registered CommandForrmal) in Command type communication. However, the contents correspond to those of the event type communication described above.

  Further, in the present embodiment, the terminal (receiving terminal / transmitting terminal) that is the leading side in Event type communication / Command type communication requests a predetermined process from the terminal (transmitting terminal / receiving terminal) that is the dependent side All flag (all flag) and Remove flag (remove flag) can be specified as options. This All flag is a flag that specifies whether to notify all or one write uTuple that matches the conditions in Event type communication to the communication terminal as the receiving terminal that has registered the read uTuple. Is a flag for designating whether or not to notify the writing uTuple to all or one of the communication terminals as receiving terminals that have registered the reading uTuple that matches the conditions in FIG. The Remove flag is a flag for designating whether or not to delete the matched write uTuple or the matched read uTuple after the notification. These All flag and Remove flag are set, for example, as an additional key and its value in uTuple (EventFormal) 72 for reading of the receiving terminal in Event type communication / uTuple (CommandActual) 74 for writing of the transmitting terminal in Command type communication. be able to.

  Next, each operation characterized by the present invention in the communication system for realizing the communication model of FIG. 2 will be described with reference to FIGS. Each process in each figure (that is, all or part of the flow in each figure (that is, each step)) is executed in each terminal using a tuple space uTupleSpace 50 as a shared memory shared in each terminal. This is realized by the programs 101 to 301 and the like.

  FIGS. 4 and 5 show the registration of the uTuple (EventActual) 71 for writing (FIG. 4) and the reading uTuple (EventFormal) in Event type communication in consideration of the All flag (all flag) and the Remove flag (removal flag). The processing flow at the time of registration 72 (FIG. 5) is shown. “All flag = True / False” and “Remove flag = True / False” can be specified independently, and the processing contents are as follows (that is, a total of four combinations are conceivable).

・ Specify "All flag = True / False" in Event type communication:
UTuple (EventFormal) 72 for writing “all (when All = True) / one (when All = False)” matching uTuple (EventFormal) 72 for reading registers the uTuple (EventFormal) 72 for reading Is notified to the receiving terminal. Here, one writing uTuple (EventActual) 71 notified to the receiving terminal when All = False is, for example, the last registered one, that is, the latest one, or one satisfying other predetermined conditions. Or it can be set as not only one but multiple things.

・ Specify “Remove flag = True / False” in Event type communication:
After the writing uTuple (EventActual) 71 matching the reading uTuple (EventFormal) 72 is notified to the receiving terminal that has registered the reading uTuple (EventFormal) 72, the writing uTuple (EventActual) 71 is “deleted”. (Remove = True) / Not removed (Remove = False) ”.

  Here, the processing flow of FIG. 4 will be described. FIG. 4 is a processing flow at the time of registration of the uTuple (EventActual) 71 for writing in Event type communication. In the following description of the processing flow of FIG. 4 and each of the following figures, the terms “EventActual”, “EventFormal”, “CommandFormal”, and “CommandActual” that identify the type of each uTuple 71, 72, 73, and 74 It shall be expressed as

  In the processing flow of FIG. 4, first, when EventActual is registered, the last registered EventFormal that matches EventActual and that has Remove = True is searched (step S101). When EventFormal is not found (in the case of “NO” in step S102), all EventFormals that match EventActual are searched (step S103). Next, the processing in steps S104 to S108 is repeated for the found N EventFormals, and EventActual is notified to the program that registered the EventFormal (step S105), and if All of EventFormal is not True (in step S106) In the case of “NO”, EventFormal is deleted (step S107). Then, EventActual is registered (step S109), and the process ends.

  On the other hand, if EventFormal is found in step S102 ("YES" in step S102), EventActual is notified to the program that registered EventFormal (step S110), and if All of EventFormal is not True (step S111). In the case of “NO”, EventFormal is deleted (step S112), and the process is terminated.

  Next, the processing flow of FIG. 5 will be described. FIG. 5 is a processing flow at the time of registration of the reading uTuple (EventFormal) 72 in Event type communication.

  In the processing flow of FIG. 5, it is first determined whether or not All = True of the registered EventFormal. If All = True (“YES” in step S201), all EventActuals that match EventFormal are searched. (Step S202). Next, the detected EventActual is notified to the program that intends to register EventFormal (step S203), and if the registered EventFormal is Remove = True (in the case of “YES” in step S204), the found EventActual is deleted. (Step S205), EventFormal is registered (Step S206), and the process ends.

  On the other hand, if All = False in step S201 (if “NO” in step S201), the last registered EventActual that matches EventFormal is searched (step S207). Then, the found EventActual is notified to the program that intends to register EventFormal (step S208), and if Remove = True (“YES” in step S209), the found EventActual is deleted (step S210). ), And the process ends.

  Next, in command type communication in consideration of the All flag and the Remove flag in FIGS. 6 and 7, when writing uTuple (CommandActual) 74 is registered (FIG. 6) and when reading uTuple (CommandFormal) 73 is registered (FIG. 6). The processing flow of 7) is shown. “All flag = True / False” and “Remove flag = True / False” can be specified independently and have the following processing contents (that is, a total of four combinations are conceivable).

・ Specify "All flag = True / False" in Command type communication:
“All (when All flag = True) / one (when All flag = False)” read uTuple (CommandFormal) 73 that matches uTuple (CommandActual) 74 for writing The corresponding writing to the receiving terminal registered UTuple (CommandActual) 74 is notified, where the reading uTuple (CommandFormal) 73 selected when All = False is, for example, the last registered one, that is, the latest one, or other predetermined conditions It is possible to use a plurality of things, not limited to one or one satisfying the above.

・ Specify “Remove flag = True / False” in Command type communication:
After the uTuple (CommandActual) 74 for writing is notified to the receiving terminal that has registered the uTuple (CommandFormal) 73 for reading that matches the uTuple (CommandActual) 74 for writing, the uTuple (CommandFormal) 73 for reading is “deleted”. (When Remove flag = True) / Not deleted (When Remove flag = False) ".

  Here, the processing flow of FIG. 6 will be described. FIG. 6 is a processing flow at the time of registering the uTuple (CommandActual) 74 for writing in Command type communication.

  In the processing flow of FIG. 6, first, it is determined whether or not All of CommandActual to be registered is true. If All = True (“YES” in step S301), all CommandFormals that match CommandActual are searched. (Step S302). Next, CommandActual is notified to the program in which the found CommandFormal is registered (Step S303), and if the CommandActual to be registered is Remove = True (in the case of “YES” in Step S304), the found CommandFormal is deleted (Step S303). S305) After registering CommandActual (step S306), the process is terminated.

  On the other hand, if All = False in step S301 (in the case of “NO” in step S301), the last registered CommandFormal that matches CommandActual is searched (step S307). Then, CommandActual is notified to the program that has registered the found CommandFormal (step S308), and if Remove = True (if “YES” in step S309), the found CommandFormal is deleted (step S310). The process is terminated.

  Next, the processing flow of FIG. 7 will be described. FIG. 7 is a processing flow at the time of registration of the reading uTuple (CommandFormal) 73 in Command type communication.

  In the processing flow of FIG. 7, first, the last registered CommandActual that matches the CommandFormal to be registered and has Remove = True is searched (step S401). Next, when CommandActual is not found (in the case of “NO” in Step S402), all CommandActuals that match CommandFormal are searched (Step S403). Next, for the found N CommandActuals, the processes in steps S404 to S408 are repeated to notify the command registered to CommandFormal of the found CommandActual (step S405), and in the case of CommandActual All flag = False ( If “NO” in step S406, CommandActual is deleted (step S407), and CommandFormal is registered (step S409). Then, the process ends.

  On the other hand, when CommandActual is found in step S402 (in the case of “YES” in step S402), the commandActual found is notified to the program for registering CommandFormal (step S410), and the CommandActual All flag = False. In this case (when “NO” in step S411), CommandActual is deleted (step S412), and the process ends.

  Further, in the present embodiment, a transmitting terminal in Event / Command communication can optionally specify an Actual-to-Formal flag and a Formal-to-Actual flag that request a receiving terminal for predetermined processing. The Actual-to-Formal flag indicates whether the EventActual 71 that matches the EventFormal 72 is notified to the receiving terminal that registered the EventFormal 72, or whether the CommandActual 74 is notified to the receiving terminal that registered the CommandFormal 73 that matches the CommandActual 74 It is information that specifies. On the other hand, the Formal-to-Actual flag is notified whether the EventFormal 72 is notified to the transmission terminal that registered the EventActual 71 that matches the EventFormal 72, or the CommandFormal 73 that matches the CommandActual 74 is notified to the transmission terminal that registered the CommandActual 74. It is information that specifies whether or not. These Actual-to-Formal flag and Formal-to-Actual flag are added to, for example, uTuple (EventActual) 71 for writing the transmitting terminal in Event type communication / uTuple (CommandActual) 74 for writing the transmitting terminal in Command type communication Key and its value can be set.

  8 and 9, when registering the uTuple (EventActual) 71 for writing in the event type communication in consideration of the Actual-to-Formal flag and the Formal-to-Actual flag (FIG. 8), and the reading uTuple (EventFormal) 72 The processing flow at the time of registration (FIG. 9) is shown. “Actual-to-Formal flag = True / False” and “Formal-to-Actual flag = True / False” can be specified independently and have the following processing contents (that is, four combinations are considered) However, the combination of the former False / the latter False is meaningless, and for the other combinations, the former True / the latter False is not known by the transmitting terminal (existing), and the former False / the latter True is received by the transmitting terminal. Pre-recognition of terminal (new), former True / latter True means post-recognition of receiving terminal by transmitting terminal (new)).

・ Specify “Actual-to-Formal = True / False” in Event type communication:
The uTuple (EventActual) 71 for writing that matches the uTuple (EventFormal) 72 for reading is “notified (when Actual-to-Formal = True) / notification to the receiving terminal that has registered the uTuple (EventFormal) 72 for reading. Not (Actual-to-Formal = False) ".

・ Specify “Formal-to-Actual = True / False” in Event type communication:
The reading uTuple (EventFormal) 72 is registered to the sending terminal that has registered the writing uTuple (EventActual) 71 that matches the reading uTuple (EventFormal) 72, and is notified (when Formal-to-Actual = True) / notification. Not done (when Formal-to-Actual = False) ".

  Here, with reference to FIG. 8, a processing flow at the time of registration of the writing uTuple (EventActual) 71 in Event type communication will be described. In the processing flow of FIG. 8, first, an EventFormal that matches an EventActual to be registered is searched (step S501). And the process of step S502 to S507 is repeatedly performed about N eventFormal found. In step S503, it is determined whether the Formal-to-Actual flag of the found EventFormal is True or not. If True (if “YES” in step S503), EventFormal is registered in the program to register EventActual. Notification is made (step S504). Next, it is determined whether or not the Actual-to-Formal flag of the found EventFormal is True. If True (if “YES” in step S505), EventActual is notified to the program that registered the EventFormal ( Step S506). And after processing about N EventFormal, EventActual is registered (step S508).

  Next, a processing flow at the time of registration of the reading uTuple (EventFormal) 72 in Event type communication will be described with reference to FIG. In the processing flow of FIG. 9, first, an EventActual that matches the registered EventFormal is searched (step S601). And the process of step S602-S607 is repeatedly performed about N eventActual found. In step S603, it is determined whether or not the found EventActual's Formal-to-Actual flag is True. If True (if “YES” in step S603), EventFormal is added to the program in which the found EventActual is registered. Notification is made (step S604). Next, it is determined whether or not the Actual-to-Formal flag of the found EventActual is True. If True (if “YES” in step S605), EventActual is notified to the program that registers EventFormal ( Step S606). And after processing about N EventActual, EventFormal is registered (step S608).

  10 and 11, when registering the writing uTuple (CommandActual) 74 in the command-type communication considering the Actual-to-Formal flag and the Formal-to-Actual flag (FIG. 10), and reading the uTuple (CommandFormal) 73 The processing flow at the time of registration is shown. “Actual-to-Formal flag = True / False” and “Formal-to-Actual flag = True / False” can be specified independently and have the following processing contents (that is, four combinations are considered) However, the combination of the former False / the latter False is meaningless, and for the other combinations, the former True / the latter False is not known by the transmitting terminal (existing), and the former False / the latter True is received by the transmitting terminal. Pre-recognition of terminal (new), former True / latter True means post-recognition of receiving terminal by transmitting terminal (new)).

-Specifying "Actual-to-Formal = True / False" in Command type communication:
The receiving uTuple (CommandActual) 74 is notified to the receiving terminal that has registered the reading uTuple (CommandFormal) 73 that matches the writing uTuple (CommandActual) 74 and is notified (when Actual-to-Formal = True) / notification. Not (Actual-to-Formal = False) ".

・ Specify “Formal-to-Actual = True / False” in Command type communication:
The reading uTuple (CommandFormal) 73 that matches the writing uTuple (CommandActual) 74 is “notified (when Formal-to-Actual = True) / notification to the transmitting terminal that has registered the uTuple (CommandActual) 74 for writing. Not done (when Formal-to-Actual = False) ".

  Here, with reference to FIG. 10, the processing flow at the time of registration of the writing uTuple (CommandActual) 74 in the command type communication will be described. In the processing flow of FIG. 10, first, a CommandFormal that matches a CommandActual to be registered is searched (step S701). And the process of step S702-S707 is repeatedly performed about N commandFormal found. In step S703, it is determined whether the Formal-to-Actual flag of the found CommandFormal is True or not. If True (if “YES” in step S703), the CommandFormal is registered in the program to register CommandActual. Notification is made (step S704). Next, it is determined whether or not the Actual-to-Formal flag of the found CommandFormal is True. If True (if “YES” in step S705), the CommandActual is notified to the program that registered the CommandFormal ( Step S706). And after processing about N CommandFormal, CommandActual is registered (step S708).

  Next, a processing flow at the time of registration of the reading uTuple (CommandFormal) 73 in Command type communication will be described with reference to FIG. In the processing flow of FIG. 11, first, a CommandActual that matches the CommandFormal to be registered is searched (step S801). And the process of step S802-S807 is repeatedly performed about N commandActual found. In step S803, it is determined whether or not the found CommandActual's Formal-to-Actual flag is True. If True (if “YES” in step S803), CommandFormal is added to the program in which the found CommandActual is registered. Notification is made (step S804). Next, it is determined whether or not the Actual-to-Formal flag of the found CommandActual is True. If True (if “YES” in step S805), the CommandActual is notified to the program that registers CommandFormal ( Step S806). And after processing about N CommandActual, CommandFormal is registered (step S808).

  In the above description, the “All flag and Remove flag”, “Actual-to-Formal flag, and Formal-to-Actual flag” are described independently, but combinations thereof (16 types in total) are naturally conceivable.

  As described above, the present embodiment has the following two features, and has the following effects.

(Feature 1) Register uTuple (CommandFormal) for reading that matches matching condition in uTuple (CommandActual) for writing in the sending terminal, include matching target in uTuple (CommandFormal) for reading in receiving terminal, and match uTuple (CommandActual) for writing The receiving uTuple (CommandActual) is notified to the receiving terminal.

(Characteristic 2) The reading uTuple (EventFormal) is notified to the transmitting terminal that has registered the writing uTuple (EventActual) matching the reading uTuple (EventFormal). Also, the reading uTuple (CommandFormal) that matches the writing uTuple (CommandActual) is notified to the transmitting terminal that has registered the writing uTuple (CommandActual).

  With these characteristics, the transmitting terminal can select the receiving terminal (Effect 1). As a result, it is necessary for the transmitting terminal to specify the receiving terminal condition (that is, the receiving terminal does not need to specify the transmitting terminal condition) like transmission / reception of an actuator command. Can be sent.

  Moreover, according to this Embodiment, the transmission terminal can grasp | ascertain a receiving terminal (effect 2). As a result, it is possible to avoid sending data wastefully even though there is no receiving terminal that actually receives the data. In addition, it is possible to track which receiving terminal has actually received the transmitted data.

  Note that the uTupleSpace 50 in FIG. 2 (or its shared memory) is a non-volatile memory such as a hard disk device, a magneto-optical disk device, or a flash memory, a storage medium that can only be read such as a CD-ROM, or a RAM (Random Access). Memory), wired or wireless communication means, or a combination of these.

  Each program 101, 201, and 301 in FIG. 2 may be realized by dedicated hardware, or may be realized by a memory and a microprocessor. Each terminal 10, 20 and 30 in FIG. 2 includes a memory and a CPU (central processing unit), and functions by loading each program in the present embodiment into a memory and executing it. It may be realized.

  1 is recorded on a computer-readable recording medium, the program recorded on the recording medium is read into a computer system, and executed to execute each process. Also good. Here, the “computer system” includes an OS and hardware such as peripheral devices.

  Further, the “computer system” includes a homepage providing environment (or display environment) if a WWW system is used. The “computer-readable recording medium” refers to a portable medium such as a flexible disk, a magneto-optical disk, a ROM, and a CD-ROM, and a storage device such as a hard disk built in the computer system. Furthermore, the “computer-readable recording medium” dynamically holds a program for a short time like a communication line when transmitting a program via a network such as the Internet or a communication line such as a telephone line. In this case, a volatile memory in a computer system serving as a server or a client in that case, and a program that holds a program for a certain period of time are also included. The program may be a program for realizing a part of the functions described above, and may be a program capable of realizing the functions described above in combination with a program already recorded in a computer system.

  The embodiment of the present invention has been described in detail with reference to the drawings. However, the specific configuration is not limited to this embodiment, and includes design and the like within a scope not departing from the gist of the present invention.

It is a schematic diagram for demonstrating the communication model (background art) of TupleSpace. It is a schematic diagram for demonstrating the communication model of TupleSpace (uTupleSpace) by this invention. It is a figure which shows the format of uTuple in embodiment of the communication system of this invention which implement | achieves the communication model of FIG. It is a processing flow in consideration of the All flag and the Remove flag at the time of EventActual registration in the embodiment of the communication system of the present invention that realizes the communication model of FIG. It is a processing flow in consideration of the All flag and Remove flag at the time of EventFormal registration in the embodiment of the communication system of the present invention that realizes the communication model of FIG. FIG. 3 is a processing flow in consideration of an All flag and a Remove flag at the time of CommandActual registration in the embodiment of the communication system of the present invention that realizes the communication model of FIG. 2. It is a processing flow in consideration of the All flag and Remove flag at the time of CommandFormal registration in the embodiment of the communication system of the present invention that realizes the communication model of FIG. FIG. 3 is a processing flow considering an Actual-to-Formal flag and a Formal-to-Actual flag at the time of EventActual registration in the embodiment of the communication system of the present invention that realizes the communication model of FIG. FIG. 3 is a processing flow considering an Actual-to-Formal flag and a Formal-to-Actual flag at the time of EventFormal registration in the embodiment of the communication system of the present invention that implements the communication model of FIG. 2. FIG. 3 is a processing flow considering an Actual-to-Formal flag and a Formal-to-Actual flag at the time of CommandActual registration in the embodiment of the communication system of the present invention that realizes the communication model of FIG. 2. FIG. 3 is a processing flow considering an Actual-to-Formal flag and a Formal-to-Actual flag at the time of CommandFormal registration in the embodiment of the communication system of the present invention that realizes the communication model of FIG. 2.

Explanation of symbols

  DESCRIPTION OF SYMBOLS 10 ... Server terminal, 20 ... Sensor terminal, 30 ... Actuator terminal, 101, 201, 301 ... Program, 40 ... Ubiquitous network (communication line or communication network), 50 ... uTupleSpace, 71 ... Write uTuple (EventActual), 72 ... UTuple for reading (EventFormal), 73 ... uTuple for reading (CommandFormal), 74 ... uTuple for writing (CommandActual)

Claims (12)

A communication means for connecting a plurality of terminals;
One or a plurality of communication terminals which are connected by the communication means and register at least one of a writing tuple and a reading tuple serving as data to be communicated in a predetermined storage means as a transmitting terminal or a receiving terminal; A system that includes information representing a matching target or a matching condition in each tuple registered in the predetermined storage means, and performs indirect communication by matching them,
The matching tuple is included in the writing tuple registered by the communication terminal serving as the transmitting terminal, and the matching target is included in the reading tuple registered by the communication terminal serving as the receiving terminal, and the reading tuple matching the writing tuple is registered. An indirect communication system characterized by notifying the writing tuple to a communication terminal serving as a receiving terminal. A communication means for connecting a plurality of terminals;
One or a plurality of communication terminals which are connected by the communication means and register at least one of a writing tuple and a reading tuple serving as data to be communicated in a predetermined storage means as a transmitting terminal or a receiving terminal; A system that includes information representing a matching target or a matching condition in each tuple registered in the predetermined storage means, and performs indirect communication by matching them,
The matching tuple is included in the writing tuple registered by the communication terminal serving as the transmitting terminal, the matching condition is included in the reading tuple registered by the communication terminal serving as the receiving terminal, and the matching target matching the reading tuple including the matching condition is included. Notify the reading tuple to the communication terminal serving as the transmitting terminal that has registered the writing tuple, or read the matching conditions registered in the writing tuple registered by the communication terminal serving as the transmitting terminal and the communication terminal registered as the receiving terminal. Indirect, characterized in that a matching target is included in the tuple, and a reading tuple that includes a matching target that matches the writing tuple including the matching condition is notified to the communication terminal that is the transmitting terminal in which the writing tuple is registered. Communications system. All of the matched tuples or one tuple for writing is notified to the communication terminal as a receiving terminal that registers the reading tuple, or all of the communication terminals as receiving terminals that register the matched reading tuple Or a flag that specifies whether to notify the tuple for writing to one,
The flag for designating whether or not to delete the matched write tuple or the matched read tuple after the notification is included in the read tuple or the write tuple. Indirect communication system. The reading tuple or the writing tuple includes a flag that specifies whether or not the reading tuple or the writing tuple is notified to the communication terminal as the transmitting terminal or the communication terminal as the receiving terminal. The indirect communication system according to claim 2 or 3. A communication means for connecting a plurality of terminals;
One or a plurality of communication terminals which are connected by the communication means and register at least one of a writing tuple and a reading tuple serving as data to be communicated in a predetermined storage means as a transmitting terminal or a receiving terminal; Use, including information representing the matching target or matching condition in each tuple registered in the predetermined storage means, and performing indirect communication by matching them,
The matching tuple is included in the writing tuple registered by the communication terminal serving as the transmitting terminal, and the matching target is included in the reading tuple registered by the communication terminal serving as the receiving terminal, and the reading tuple matching the writing tuple is registered. An indirect communication method comprising: notifying a communication terminal as a receiving terminal of the writing tuple. A communication means for connecting a plurality of terminals;
One or a plurality of communication terminals which are connected by the communication means and register at least one of a writing tuple and a reading tuple serving as data to be communicated in a predetermined storage means as a transmitting terminal or a receiving terminal; Use, including information representing the matching target or matching condition in each tuple registered in the predetermined storage means, and performing indirect communication by matching them,
The matching tuple is included in the writing tuple registered by the communication terminal serving as the transmitting terminal, the matching condition is included in the reading tuple registered by the communication terminal serving as the receiving terminal, and the matching target matching the reading tuple including the matching condition is included. Notify the reading tuple to the communication terminal serving as the transmitting terminal that has registered the writing tuple, or read the matching conditions registered in the writing tuple registered by the communication terminal serving as the transmitting terminal and the communication terminal registered as the receiving terminal. Indirect, characterized in that a matching target is included in the tuple, and a reading tuple that includes a matching target that matches the writing tuple including the matching condition is notified to the communication terminal that is the transmitting terminal in which the writing tuple is registered. Communication method. All of the matched tuples or one tuple for writing is notified to the communication terminal as a receiving terminal that registers the reading tuple, or all of the communication terminals as receiving terminals that register the matched reading tuple Or a flag that specifies whether to notify the tuple for writing to one,
7. The read tuple or the write tuple is included in the read tuple or a flag that specifies whether or not to delete the matched write tuple or the matched read tuple after the notification. Indirect communication method as described in. The reading tuple or the writing tuple includes a flag that specifies whether or not the reading tuple or the writing tuple is notified to the communication terminal as the transmitting terminal or the communication terminal as the receiving terminal. The indirect communication method according to claim 6 or 7. A communication means for connecting a plurality of terminals;
One or a plurality of communication terminals which are connected by the communication means and register at least one of a writing tuple and a reading tuple serving as data to be communicated in a predetermined storage means as a transmitting terminal or a receiving terminal; Use each tuple registered in the predetermined storage means to include information representing the matching target or matching condition, and when performing indirect communication by matching them,
The matching tuple is included in the writing tuple registered by the communication terminal serving as the transmitting terminal, and the matching target is included in the reading tuple registered by the communication terminal serving as the receiving terminal, and the reading tuple matching the writing tuple is registered. An indirect communication program comprising a description for executing, using a computer, processing for notifying a communication terminal as a receiving terminal of the writing tuple. A communication means for connecting a plurality of terminals;
One or a plurality of communication terminals which are connected by the communication means and register at least one of a writing tuple and a reading tuple serving as data to be communicated in a predetermined storage means as a transmitting terminal or a receiving terminal; Use each tuple registered in the predetermined storage means to include information representing the matching target or matching condition, and when performing indirect communication by matching them,
The matching tuple is included in the writing tuple registered by the communication terminal serving as the transmitting terminal, the matching condition is included in the reading tuple registered by the communication terminal serving as the receiving terminal, and the matching target matching the reading tuple including the matching condition is included. Notify the reading tuple to the communication terminal serving as the transmitting terminal that has registered the writing tuple, or read the matching conditions registered in the writing tuple registered by the communication terminal serving as the transmitting terminal and the communication terminal registered as the receiving terminal. The computer includes a process for notifying a communication terminal serving as a transmitting terminal that has registered the writing tuple, including a matching target in the tuple and a reading tuple including the matching target that matches the writing tuple including the matching condition. Contains a description to use and execute Indirect communication program characterized. All of the matched tuples or one tuple for writing is notified to the communication terminal as a receiving terminal that registers the reading tuple, or all of the communication terminals as receiving terminals that register the matched reading tuple Or a flag that specifies whether to notify the tuple for writing to one,
After these notifications, a process for including in the read tuple or the write tuple a flag for designating whether or not to delete the matched write tuple or the matched read tuple is used by using a computer. The indirect communication program according to claim 10, comprising a description for execution. Processing for including in the reading tuple or the writing tuple a flag specifying whether or not to notify the reading tuple or the writing tuple to the communication terminal as the transmitting terminal or the communication terminal as the receiving terminal The indirect communication program according to claim 10 or 11, further comprising: a description for executing the program using a computer.

Images