Integrating rules into object-oriented programming systems

• US 5,768,480 A
• Filed: 10/21/1994
• Issued: 06/16/1998
• Est. Priority Date: 10/21/1994
• Status: Expired due to Term

• Current Assignee: Nokia of America Corporation (Nokia Corporation)
• Original Assignee: Lucent Technologies, Inc. (Nokia Corporation)
• Inventors: Litman, Diane Judith, Dvorak, Daniel L., Mishra, Anil K., Crawford, James Melton Jr., Patel-Schneider, Peter Frederick
• Primary Examiner(s): Hafiz, Tariq R.
• Application Number:
  US08/327,336
• Time in Patent Office: 1,334 Days
• Field of Search: 395/50, 395/51, 395/60-62, 395/76, 395/700, 395/705, 395/702, 364/280, 364/280.4
• US Class Current: 706/47
• CPC Class Codes: G06F 8/315 Object-oriented languages
• CPC Class Codes: G06N 5/046 Forward inferencing; Production systems

Abstract

Techniques for integrating rules into imperative object-oriented languages such as C++. C++ is extended to permit definition of rules as members of classes. When a rule is defined as a member of a class, a preprocessor receives the declaration of the rule'"'"'s class and of any other class involved in the rule and generates additional data members and member functions for the classes. The additional members of the classes permit a complete implementation of the rule. No additional rule interpreter or decision network is required. The rule definition defines collections of objects linked by interobject pointers to which the rule applies. A rule is evaluated only if there is a change in a value mentioned in the rule in an object belonging to a collection of objects for the rule. The rule'"'"'s condition is a sequence of bindings and tests. The bindings define a path through a collections of objects to which the rule applies, and the path is followed during evaluation. The rules thus implement access-limited logic.

Claims

1. An apparatus implemented in a computer system for producing executable code for a system wherein a rule responds to a change in data belonging to the system, the apparatus comprising:

a rule definition stored in the computer system as at least one member of a class having path-based rules, the rule definition for specifying a collection of data structures in which the change occurs; and

code generation means responsive to the rule definition for producing executable code associated with the data structures, wherein the executable code is an implementation of the rule and includes one or more instantiation functions which execute in response to the change and a triggering function which detects the change and invokes the instantiation function.

2. The apparatus set forth in claim 1 wherein:

the change is creating a data structure belonging to the collection.

3. The apparatus set forth in claim 1 wherein:

the change is a change in a value in a data structure belonging to the collection.

4. The apparatus set forth in claim 1 wherein:

the rule definition comprises

a condition specifier which specifies a condition involving the data structures in the collection and

an action specifier which specifies an action to be executed when the condition is satisfied; and

the instantiation function responds to the triggering function by evaluating the condition and executing the action when the condition is satisfied.

5. The apparatus set forth in claim 4 wherein:

the data structures in the collection include at least a root data structure from which the instantiation function begins evaluating the condition.

6. The apparatus set forth in claim 5 wherein:

the data structures in the collection further includes a neighbor data structure which is accessible from the root data structure and which is mentioned in the condition specifier; and

the instantiation function continues evaluating the condition using the neighbor data structure.

7. The apparatus set forth in claim 6 wherein:

there is at least one set of the neighbor data structures;

the condition includes a local variable;

the instantiation function evaluates the condition by binding the local variable in turn to as many of the neighbor data structures in the set as are required for evaluation.

8. The apparatus set forth in claim 7 wherein:

the condition further includes a quantifier which operates on the local variable; and

the instantiation function binds the local variable to the neighbor data structures as required by the quantifier.

9. The apparatus set forth in claim 8 wherein:

the quantifier is in the alternative a universal quantifier and an existential quantifier.

10. The apparatus set forth in claim 6 wherein:

the instantiation function evaluates the condition using only the root data structure and any neighbor data structure.

11. The apparatus set forth in claim 6 wherein:

the executable code includes code which establishes a set of root pointers in the neighbor data structure; and

when evaluating the condition using the neighbor data structure, the instantiation function adds any necessary root pointer to the root data structure to the set of root pointers.

12. The apparatus set forth in claim 11 wherein:

when the change is in the neighbor data structure, the instantiation function follows the root pointer to the root data structure.

13. The apparatus set forth in claim 6 wherein:

there is a plurality of the neighbor data structures; and

when the change is in one of the neighbor data structures, the instantiation function evaluates the condition only until the condition has been evaluated for the neighbor data structure in which the change occurred.

14. The apparatus set forth in any of claims 1 through 13 wherein:

the data structures in the collection are defined as objects belonging to at least one class; and

the apparatus further includes a class definition for the class stored in the computer system; and

the code generation means is further responsive to the class definition and defines the executable code as code for at least one additional member of the class definition.

15. The apparatus set forth in claim 14 wherein:

the code generation means produces the additional member using substantially nothing but the rule definition and the class definition.

16. The apparatus set forth in claim 14 wherein:

the rule definition defines the rule as a member of the class.

17. The apparatus set forth in claim 16 wherein:

the rule and the additional member are inherited and may be redefined in the same fashion as other members of the class.

18. The apparatus set forth in claim 14 wherein:

the class is the class of the root object.

19. An apparatus implemented in a computer system for producing executable code for a system wherein a rule responds to a change in data belonging to the system, the apparatus comprising:

a rule definition stored in the computer system which specifies a collection of data structures in which the change occurs; and

code generation means responsive to the rule definition for producing executable code associated with the data structures, wherein the executed code is an implementation of the rule and is based solely on a rule-definition code and an object-oriented code and includes one or more instantiation functions which execute in response to the change and a triggering function which detects the change and invokes the instantiation function.

20. An apparatus implemented in a computer system for producing executable code for a system wherein a rule responds to a change in data belonging to the system, the apparatus comprising:

a rule definition stored in the computer system which specifies a collection of data structures in which the change occurs; and

code generation means responsive to the rule definition for producing executable code associated with the data structures, wherein the executable code is an implementation of the rule and includes executable code for at least one instantiation function which executes in response to the change and executable code for a triggering function which detects the change and invokes the at least one instantiation function, and said triggering function and said at least one instantiation function are embedded solely in a rule-definition code and an object-oriented code.