Application framework providing a registry for mapping names to component instances

• US 10,061,626 B2
• Filed: 06/16/2014
• Issued: 08/28/2018
• Est. Priority Date: 06/05/2013
• Status: Active Grant

• Current Assignee: Splunk Inc. (Cisco Systems, Inc.)
• Original Assignee: Splunk Inc. (Cisco Systems, Inc.)
• Inventors: Neeman, Itay A.
• Primary Examiner(s): Bragdon, Reginald Glenwood
• Assistant Examiner(s): Verdi, Kimbleann C
• Application Number:
  US14/305,661
• Publication Number:
  US 20140366044A1
• Time in Patent Office: 1,534 Days
• Field of Search: 707103
• CPC Class Codes: G06F 2209/545 Gui
• CPC Class Codes: G06F 8/70 Software maintenance or management
• CPC Class Codes: G06F 8/71 Version control security arrangements therefor G06F21/57; Configuration management
• CPC Class Codes: G06F 9/44505 Configuring for program initiating, e.g. using registry, configuration files
• CPC Class Codes: G06F 9/4451 User profiles; Roaming
• CPC Class Codes: G06F 9/44521 Dynamic linking or loading; Link editing at or after load time, e.g. Java class loading
• CPC Class Codes: G06F 9/451 Execution arrangements for user interfaces
• CPC Class Codes: G06F 9/54 Interprogram communication
• CPC Class Codes: G06F 9/542 Event management; Broadcasting; Multicasting; Notifications

Abstract

The disclosed embodiments relate to a system that facilitates developing applications in a component-based software development environment. This system provides an execution environment comprising instances of application components and a registry that maps names to instances of application components. Upon receiving a call to register a mapping between a name and an instance of an application component, the system updates the registry to include an entry for the mapping. Moreover, upon receiving a call to be notified about registry changes for a name, the system updates the registry to send a notification to a caller when a registry change occurs for the name.

Claims

1. A computer-implemented method, comprising:

operating an execution environment comprising instances of application components and a registry comprising entries for registered dynamic pointers that map callers of the instances of application components to pointer names of the registered dynamic pointers using input links and having definitions that map the registered dynamic pointer names to targets of the instances of application components using output links, wherein an entry of the entries for a first of the registered dynamic pointers comprises;

a first of the input links comprising a first element that identifies a first of the callers and a second element that identifies the first registered dynamic pointer; and

a first of the output links comprising a third element that identifies the first registered dynamic pointer and a fourth element that identifies a first of the targets; and

while operating the execution environment;

upon receiving a call to register an unregistered dynamic pointer before creating a corresponding second of the targets, registering the unregistered dynamic pointer as a second of the registered dynamic pointers by updating the registry to include an entry for the unregistered dynamic pointer without identifying the second target;

upon receiving a call from a first requesting caller to be notified about a modification to a definition of a third of the registered dynamic pointers set to point to a third of the targets, the modification changing the definition of the third registered dynamic pointer to point to a fourth of the targets, registering the first requesting caller as a second of the callers by updating the registry to send a notification to the second caller when the modification occurs; and

upon receiving a call from a second requesting caller to be notified when the second target is created, registering the second requesting caller as a third of the callers by updating the registry to send a notification to the third caller when the second target instance is created.

2. The computer-implemented method of claim 1, wherein upon receiving the notification about the modification to the definition of the third registered dynamic pointer, the second caller executes a callback function, wherein the callback function receives as a parameter a reference to the fourth target.

3. The computer-implemented method of claim 1, wherein upon receiving a call to revoke one of the definitions for one of the registered dynamic pointers, removing the one of the definitions from the registry.

4. The computer-implemented method of claim 1, wherein upon receiving a call to resolve one of the registered dynamic pointers, looking up a corresponding one of the entries in the registry for the one of the registered dynamic pointers, and returning a reference to a corresponding one of the targets identified in the corresponding one of the entries.

5. The computer-implemented method of claim 1, wherein upon receiving the notification about the modification to the definition of the third registered dynamic pointer, the second caller updates one or more associated references to point to the fourth target.

6. The computer-implemented method of claim 1, wherein the calls are received through an application programming interface (API) that defines operations performed on the registry, wherein the API defines:

a register instance function that maps one of the registered dynamic pointer names to a corresponding one of the targets;

a revoke instance function that revokes one of the definitions for one of the registered dynamic pointers;

a has instance function that returns a Boolean value indicating whether the registry includes an entry for a first specified dynamic pointer name;

a get instance function that returns a reference to a corresponding one of the targets for a second specified dynamic pointer name; and

an on change function that registers a corresponding caller to be notified about registry changes associated with a third specified dynamic pointer name.

7. The computer-implemented method of claim 1, wherein the instances of the application components include at least one of:

a visual element in a user interface (UI);

an input element in the UI;

a function that produces a data value;

a token containing a variable that holds the data value;

or

another data source.

8. The computer-implemented method of claim 1, wherein the execution environment is associated with a browser session.

9. The computer-implemented method of claim 1, wherein the execution environment supports a user interface (UI) system.

10. The computer-implemented method of claim 1, wherein the method further comprises:

obtaining the definitions from the entries in the registry;

constructing a presentation that graphically represents the obtained definitions; and

outputting the presentation to a user.

11. The computer-implemented method of claim 1, wherein the method further comprises:

detecting a series of changes to the registry;

associating each detected change with a time that each of the detected changes occurred;

constructing a presentation that graphically represents the series of changes and the associated times for the series of changes; and

outputting the presentation to a user.

12. A non-transitory computer-readable storage medium storing instructions that when executed by a computer cause the computer to perform a method, comprising:

operating an execution environment comprising instances of application components and a registry comprising entries for registered dynamic pointers that map callers of the instances of application components to pointer names of the registered dynamic pointers using input links and having definitions that map the registered dynamic pointer names to targets of the instances of application components using output links, wherein an entry of the entries for a first of the registered dynamic pointers comprises;

a first of the input links comprising a first element that identifies a first of the callers and a second element that identifies the first registered dynamic pointer; and

a first of the output links comprising a third element that identifies the first registered dynamic pointer and a fourth element that identifies a first of the targets; and

while operating the execution environment;

upon receiving a call to register an unregistered dynamic pointer before creating a corresponding second of the targets, registering the unregistered dynamic pointer as a second of the registered dynamic pointers by updating the registry to include an entry for the unregistered dynamic pointer without identifying the second target;

upon receiving a call from a first requesting caller to be notified about a modification to a definition of a third of the registered dynamic pointers set to point to a third of the targets, the modification changing the definition of the third registered dynamic pointer to point to a fourth of the targets, registering the first requesting caller as a second of the callers by updating the registry to send a notification to the second caller when the modification occurs; and

upon receiving a call from a second requesting caller to be notified when the second target is created, registering the second requesting caller as a third of the callers by updating the registry to send a notification to the third caller when the second target is created.

13. The non-transitory computer-readable storage medium of claim 12, wherein upon receiving the notification about the modification to the definition of the third registered dynamic pointer, the second caller executes a callback function, wherein the callback function receives as a parameter a reference to the fourth target.

14. The non-transitory computer-readable storage medium of claim 12, wherein upon receiving a call to revoke one of the definitions for one of the registered dynamic pointers, the method further comprises removing the one of the definitions from the registry.

15. The non-transitory computer-readable storage medium of claim 12, wherein upon receiving a call to resolve one of the registered dynamic pointers, the method further comprises looking up a corresponding one of the entries in the registry for the one of the registered dynamic pointers, and returning a reference to a corresponding one of the targets identified in the corresponding one of the entries.

16. The non-transitory computer-readable storage medium of claim 12, wherein upon receiving the notification about the modification to the definition of the third registered dynamic pointer, the second caller updates one or more associated references to point to the fourth target.

17. The non-transitory computer-readable storage medium of claim 12, wherein the calls are received through an application programing interface (API) that defines operations performed on the registry, wherein the API defines:

a register instance function that maps one of the registered dynamic pointer names to a corresponding one of the targets;

a revoke instance function that revokes one of the definitions for one of the registered dynamic pointers;

a has instance function that returns a Boolean value indicating whether the registry includes an entry for a first specified dynamic pointer name;

a get instance function that returns a reference to a corresponding one of the targets for a second specified dynamic pointer name; and

an on change function that registers a corresponding caller to be notified about registry changes associated with a third specified dynamic pointer name.

18. The non-transitory computer-readable storage medium of claim 12, wherein the instances of the application components include at least one of:

a visual element in a user interface (UI);

an input element in the UI;

a function that produces a data value;

a token containing a variable that holds the data value; and

or another data source.

19. The non-transitory computer-readable storage medium of claim 12, wherein the execution environment supports a user interface (UI) system.

20. The non-transitory computer-readable storage medium of claim 12, wherein the method further comprises:

obtaining the definitions from the entries in the registry;

constructing a presentation that graphically represents the obtained definitions; and

outputting the presentation to a user.

21. The non-transitory computer-readable storage medium of claim 12, wherein the method further comprises:

detecting a series of changes to the registry;

associating each detected change with a time that each of the detected changes occurred;

constructing a presentation that graphically represents the series of changes and the associated times for the series of changes; and

outputting the presentation to a user.

22. A system, comprising:

at least one processor and at least one associated memory; and

an execution environment configured to execute on the at least one processor and comprising instances of application components and a registry comprising entries for registered dynamic pointers that map callers of the instances of application components to pointer names of the registered dynamic pointers using input links and having definitions that map the registered dynamic pointer names to targets of the instances of application components using output links, wherein an entry of the entries for a first of the registered dynamic pointers comprises;

a first of the input links comprising a first element that identifies a first of the callers and a second element that identifies the first registered dynamic pointer; and

a first of the output links comprising a third element that identifies the first registered dynamic pointer and a fourth element that identifies a first of the targets; and

wherein the execution software development environment is configured to;

upon receiving a call to register an unregistered dynamic pointer before creating a corresponding second of the targets, registering the unregistered dynamic pointer as a second of the registered dynamic pointers by updating the registry to include an entry for the unregistered dynamic pointer without identifying the second target;

upon receiving a call from a first requesting caller to be notified about a modification to a definition of a third of the registered dynamic pointers set to point to a third of the targets, the modification changing the definition of the third registered dynamic pointer to point to a fourth of the targets, registering the first requesting caller as a second of the callers by updating the registry to send a notification to the second caller when the modification occurs; and

upon receiving a call from a second requesting caller to be notified when the second target is created for the name, registering the second requesting caller as a third of the callers by updating the registry to send a notification to the third caller when the second target is created.

23. The system of claim 22, wherein upon receiving the notification about the modification to the definition of the third registered dynamic pointer, the second caller is configured to execute a callback function, wherein the callback function receives as a parameter a reference to the fourth target.

24. The system of claim 22, wherein upon receiving a call to revoke one of the definitions for one of the registered dynamic pointers, the execution environment is configured to remove the one of the definitions from the registry.

25. The system of claim 22, wherein upon receiving a call to resolve one of the registered dynamic pointers, the execution environment is configured to look up a corresponding one of the entries in the registry for the one of the registered dynamic pointers, and return a reference to a corresponding one of the targets in the corresponding one of the entries.

26. The system of claim 22, wherein upon receiving the notification about the modification to the definition of the third registered dynamic pointer, the second caller is configured to update one or more associated references to point to the fourth target.

27. The system of claim 22, wherein the execution environment is configured to provide an application programing interface (API) that defines operations performed on the registry, wherein the API defines:

a register instance function that maps one of the registered dynamic pointer names to a corresponding one of the targets;

a revoke instance function that revokes one of the definitions for one of the registered dynamic pointers;

a has instance function that returns a Boolean value indicating whether the registry includes an entry for a first specified dynamic pointer name;

a get instance function that returns a reference to a corresponding one of the targets for a second specified dynamic pointer name; and

an on change function that registers a corresponding caller to be notified about registry changes associated with a third specified dynamic pointer name.

28. The system of claim 22, wherein the instances of the application components include at least one of:

a visual element in a user interface (UI);

an input element in the UI;

a function that produces a data value;

a token containing a variable that holds the data value;

or

another data source.

29. The system of claim 22, wherein the execution environment is additionally configured to:

obtain the definitions from the entries in the registry;

construct a presentation that graphically represents the obtained definitions; and

output the presentation to a user.

30. The system of claim 22, wherein the execution environment is additionally configured to:

detect a series of changes to the registry;

associate each detected change with a time that each of the detected changes occurred;

construct a presentation that graphically represents the series of changes and the associated times for the series of changes; and

output the presentation to a user.