COMPUTING PLATFORM BASED ON A HIERARCHY OF NESTED DATA STRUCTURES

• US 20100205205A1
• Filed: 02/05/2010
• Published: 08/12/2010
• Est. Priority Date: 02/06/2009
• Status: Active Grant

• Current Assignee: It Actual Sendirian Berhad
• Original Assignee: It Actual Sendirian Berhad
• Inventors: Hamel, Greg
• Granted Patent: US 8,401,992 B2
• Time in Patent Office: Days
• US Class Current: 707/769
• CPC Class Codes: G06F 16/20 of structured data, e.g. relational data
• CPC Class Codes: G06F 16/22 Indexing; Data structures therefor; Storage structures
• CPC Class Codes: G06F 16/9017 using directory or table look-up use of a directory or look-up table in file systems G06F16/13
• CPC Class Codes: G06F 16/9024 Graphs; Linked lists G06F16/9027 takes precedence

Abstract

Embodiments of the invention may provide a computing platform, a business rules engine, a method, a system, and a user interface for building a computing platform, where each is based on a hierarchy of nested data structures and an application programming interface defining functions. The functions comprise at least one function for nesting one or more data structures within the contents of an enclosing data structures such that nesting the one or more data structures within the contents of the enclosing data structures results in a hierarchy of nested data structures; at least one function for removing one or more data structures from the contents of the enclosing data structures; at least one function for retrieving one or more data structures from the contents of the enclosing data structures; and at least one function for modifying the contents of one or more data structures. Each of the functions may receive a data structures as a parameter. The functions for retrieving and removing receive a pattern as the parameter, the pattern having a head concept and nested concepts. The functions match the contents of the data structures against the pattern in a recursive manner, wherein the matching is first by the head concept and then by the zero or more nested concepts.

Claims

1. A computing platform configured as a hierarchy of nested data structures, the computing platform comprising a processor and memory storing instructions, the instructions being executable to configure the processor to provide:

an application programming interface for a data structure, wherein each data structure comprises contents, and wherein the application programming interface defines;

at least one function for nesting one or more data structures within the contents of an enclosing data structure such that nesting the data structures within the contents of the enclosing data structure results in a hierarchy of nested data structures;

at least one function for removing one or more data structures from the contents of the enclosing data structure;

at least one function for retrieving one or more data structures from the contents of the enclosing data structure; and

at least one function for modifying the contents of one or more data structures;

wherein each of the plurality functions receives one or more data structures as a parameter;

wherein the function for removing and the function for retrieving receives as the parameter a pattern defining a template for one or more data structures of interest, the pattern having a head concept and zero or more nested concepts, wherein the concept is an ordered list of elements identifying a concept name and structure; and

wherein the function for removing and the function for retrieving matches the contents of the enclosing data structure against the pattern in a recursive manner, matching first by the head concept and then by the zero or more nested concepts.

2. The computing platform of claim 1, wherein the function for removing and the function for retrieving are operable to return a hierarchy of nested data structures from the contents of the enclosing data structure, and wherein the returned hierarchy of nested data structures can be queried using the functions defined by the application programming interface.

3. The computing platform of claim 1 wherein the data structure is selected from the group consisting of:

a tuple space, an object, and an atomic data type.

4. The computing platform of claim 1, wherein each data structure is associated with an identifier, wherein the identifier is an address of the data structure within an enclosing data structure.

5. The computing platform of claim 1, wherein the instructions further configure the processor to provide an ontology component to define one or more concept membership sets, wherein the concept membership set is an ordered set of elements identifying one or more concepts, and wherein each data structure is associated with a concept membership set.

6. The computing platform of claim 5 wherein each the concept membership set for each data structure has a root concept, wherein the root concept is the least specialized concept of the concept membership set.

7. The computing platform of claim 5 wherein the ontology component is configured to compute and return the concept membership set of a data structure;

and wherein the application programming interface further defines at least one function for returning the concept membership set of the data structure, wherein the returned concept membership set is embodied in a data structure.

8. The computing platform of claim 5 wherein each data structure comprises a head concept, wherein the head concept is the most specialized concept of the concept membership set;

and wherein the application programming interface further defines at least one function for returning the head concept of the data structure, wherein the returned head concept is embodied in a data structure.

9. The computing platform of claim 8 wherein the data structure comprises an identifier, wherein the identifier is a unique address of the data structure within an enclosing data structure.

10. The computing platform of claim 1 wherein the application programming interface further defines one or more functions for defining “

is-a”

relationships between two or more concepts.

11. The computing platform of claim 1, wherein the application programming interface further defines a function for serializing the hierarchy of nested data structures to an intermediate form and from the intermediate form while preserving the configuration of the data structure.

12. The computing platform of claim 1, wherein the application programming interface further defines a function for transforming an object form of a hierarchy of nested data structures into a secondary representation suitable for transmission over a network;

and a function for transmitting the secondary representation over a network.

13. The computing platform of claim 1, wherein the application programming interface further provides a function for transforming an object form of the hierarchy of nested data structures into a secondary representation suitable for storage;

and a function for storing the secondary representation.

14. The computing platform of claim 1 wherein the plurality of functions further comprises a function for creating a copy of the hierarchy of nested data structures.

15. The computing platform of claim 1 wherein the instructions further configure the processor to provide an expression language;

wherein the expression language has an evaluation context that is a data structure;

wherein the expression language comprises a plurality of functions, wherein each function is embodied in a data structure.

16. The computing platform of claim 1 wherein the application programming interface further defines at least one function for returning a hierarchical address of a data structure within the hierarchy of nested data structures, wherein the hierarchical address is embodied in a data structure.

17. The computing platform of claim 1 wherein the instructions further configure the processor to provide an event model and wherein each of the functions generate an event by invoking an event notification function to signify a query of the data structure or a change in contents of the data structure.

18. The computing platform of claim 17 wherein each event comprises:

a reference to the data structure where the query or change in contents originated;

a type of query or change in contents; and

before and after values of the data structure where the query or change in contents originated.

19. The computing platform of claim 18 wherein the event model is comprised of a “

pre-phase”

for changes or queries that are about to occur in the contents and a “

post-phase”

for queries or changes that have occurred in the contents.

20. The computing platform of claim 19 wherein for each of the “

pre-phase” and

the “

post-phase”

the event model determines a before state and an after state of the tuple space which is the subject of the event.

21. The computing platform of claim 17 wherein the instructions further configure the processor to provide one or more observers, each observer defining one or more functions of interest;

one or more phases of interest; and

a pattern describing a configuration of a data structure of interest;

wherein each observer is embodied as a data structure;

wherein each observer may be active or inactive; and

wherein each active observer monitors its enclosing data structure for one or more events associated with the pattern.

22. The computing platform of claim 21 wherein each observer may be nested into an enclosing data structure such that the observer forms part of the contents of the enclosing data structure.

23. The computing platform of claim 21 wherein each event propagates to an active observer of the data structure where the change in contents originated and then to one or more active observers in one or more enclosing data structures.

24. The computing platform of claim 21 wherein the application programming interface further defines at least one function for notifying one or more enclosing data structures of a change in the contents of a nested data structure.

25. The computing platform of claim 24 wherein the at least one function for notifying operates by (a) locating one or more active observers of an observed data structure, and querying the one or more active observers for interest in the event;

(b) queuing a notification to each of the one or more active observers interested in the event;

(c) propagating the event to one or more data structures enclosing the subject data structure;

(d) issuing the queued notifications to observers interested in the event.

26. The computing platform of claim 21 wherein each observer supports a call back handler for providing a notification to a data structure when the pattern and the function of interest defined by the observer are detected within the observed data structure.

27. The computing platform of claim 21 wherein the hierarchy of nested data structures may be queried for one or more observers using one or more of the plurality of functions and the pattern defined by the observer.

28. The computing platform of claim 24 wherein the at least one function for notifying operates by first notifying the data structure that is the subject of the change, and then by notifying one or more data structures that are ancestors in the hierarchy of nested data structures.

29. The computing platform of claim 24 wherein the function for notifying notifies the data structure of the change within its contents using the pattern received as the parameter of the function

30. The computing platform of claim 17 further comprising one or more rules for generating productions, wherein each rule comprises:

nested data structures defining antecedent conditions of the production rule;

nested data structures defining consequent actions of the production rule; and

nested data structures for storing a state of a matching algorithm;

wherein each rule is embodied in a data structure;

wherein each rule can be nested into an enclosing data structure such that the rule forms part of the contents of its enclosing data structure

wherein each rule is capable of processing events to generate one or more productions wherein each production is a binding set containing zero or more data structures; and

wherein each rule provides a reasoning mechanism for its enclosing data structure.

31. The computing platform of claim 30 wherein the instructions further configure the processor to provide a default agenda;

wherein, after an operation of any of the functions, the agenda queries an enclosing data structure for rules having generated one or more productions, and wherein the agenda causes the rules to fire actions on each generated production in a sequence until no additional productions exist; and

wherein the agenda supports a salience of rules of its enclosing data structure by virtue of the order in which the rules are nested within the enclosing data structure.

32. The computing platform of claim 31 wherein the instructions further configure the processor to provide a custom agenda, wherein the custom agenda is embodied in a data structure and is operable to be nested within an enclosing data structure to override the behavior of the default agenda.

33. The computing platform of claim 30 wherein a rule is capable of reasoning about another rule.

34. The computing platform of claim 30 wherein the plurality of functions further includes a function for finding unifications of variable bindings across a plurality of concepts.

35. The computing platform of claim 4 wherein each data structure can be queried for its entire contents by providing the pattern for the least specialized root concept as a parameter for one of the functions of the application programming interface.

36. The computing platform of claim 1 wherein the instructions further configure the processor to provide:

a user interface library;

a display adapter for displaying a plurality of user interface elements;

a registry of view definitions for rendering patterns associated with the data structures; and

a user interface adapter library for associating the plurality of user interface elements with the hierarchy of nested data structures;

37. The computing platform of claim 1 wherein the instructions further configure the processor to provide:

a runtime library for implementing the application programming interface on a host operating system; and

an executable image embodying the application programming interface in a format suitable for use on the host operating system.

39. The business rules engine of claim 37 wherein the rule base supports pattern matching between facts across a plurality of concepts.

40. The business rules engine of claim 37 wherein the matching algorithm implements a network in the working memory, the network comprising a plurality of nodes for intra-fact tests, an alpha memory, a plurality of nodes for inter-fact correlations across two concepts and a beta memory.

41. The business rules engine of claim 40 wherein the matching algorithm is implemented as the RETE algorithm.

42. The business rules engine of claim 37 further comprising an agenda for operating on one or more productions generated by the production rules.

43. A non-transitory physical computer-readable medium upon which a plurality of instructions are stored, the instructions being executable to configure a processor to provide the application programming interface as defined in claim 1.

38. A business rules engine comprising:

a working memory, wherein the working memory is implemented as a hierarchy of nested data structures;

a processor configured to interface with an application programming interface defining a plurality of functions;

at least one function for nesting one or more data structures within an enclosing data structure;

at least one function for removing one or more data structures from an enclosing data structure;

at least one function for retrieving one or more data structures from an enclosing data structure; and

at least one function for modifying one or more data structures;

wherein the function for removing and the function for retrieving receives as the parameter a pattern defining a template for one or more data structures of interest, the pattern having a head concept and zero or more nested concepts, wherein the concept is an ordered list of elements identifying a concept name and structure; and

wherein the function for removing and the function for retrieving matches the contents of the enclosing data structure against the pattern in a recursive manner, matching first by the head concept and then by zero or more nested concepts;

a rulebase comprising a plurality of rules, wherein each rule is embodied as a data structure and comprises;

a nested data structure for storing the antecedent conditions of the rule;

a nested data structure for storing the consequent actions of the rule; and

a nested data structure for storing the state of a matching algorithm;

wherein, in operation, facts can be asserted into the working memory, wherein each fact is embodied in a data structure; and

wherein, in operation, the plurality of rules operate on the facts in the working memory to generation one or more productions.