Object oriented framework mechanism for multi-target source code processing

• US 6,434,739 B1
• Filed: 04/22/1996
• Issued: 08/13/2002
• Est. Priority Date: 04/22/1996
• Status: Expired due to Term

• Current Assignee: LinkedIn Corporation (Microsoft Corporation)
• Original Assignee: International Business Machines Corporation
• Inventors: Misheski, David Joseph, Stupca, Stephen Matthew, Branson, Michael John
• Primary Examiner(s): Chaki, Kakali
• Application Number:
  US08/636,211
• Time in Patent Office: 2,304 Days
• Field of Search: 395/701, 395/705, 395/685, 717/100-109, 717/120-123, 717/136, 707/103.R, 707/103.Y, 707/103, 707/103.Z, 709/315
• US Class Current: 717/108
• CPC Class Codes: G06F 8/71 Version control security arrangements therefor G06F21/57; Configuration management
• CPC Class Codes: Y10S 707/99944 Object-oriented database structure

Abstract

An object oriented framework for source code processing provides an infrastructure that embodies the steps necessary to process source code and a mechanism to extend the framework to fit a particular scenario for processing source code. Certain core functions are provided by the framework, which interact with extensible functions provided by the framework user. The architecture of the framework allows a developer to select the native processing tool of their choice, and provides an infrastructure for using that processing tool with other platforms (e.g., targets, etc.) The extensible functions allow the processing tools of a new platform to be easily incorporated into the framework. The framework thus allows a programming environment with development on multiple platforms that targets multiple platforms, which may be easily customized to include new platforms and new processing tools.

Claims

1. A computer system, the computer system comprising:

a central processing unit; and

a main memory coupled to the central processing unit, the main memory containing a framework that provides an extensible source code processing system for processing at least one source code module within a source code program, the framework comprising at least one extensible class, the framework executing on the central processing unit.

2. The computer system of claim 1 wherein the framework defines a processing configuration class comprising:

at least one processing configuration object that defines at least one processing configuration; and

a first set of object methods to effect the processing of the at least one source code module.

3. The computer system of claim 2 wherein the first set of object methods collect a list of candidate source code modules including the at least one source code module, to check the dependencies of the at least one source code module to other modules in the source code program, to check the currency of the at least one source code module, and to assemble commands for the processing configuration to cause the at least one source code module to be processed.

4. The computer system of claim 2 wherein the first set of object methods in the processing configuration class includes at least one method to distribute the source code processing to at least one external computer system.

5. The computer system of claim 2 wherein the framework further defines a candidate collector class, a dependency checker class, a currency checker class, and a command assembler class, and wherein the processing configuration class has a “

has a”

relationship with each of the candidate collector class, the currency checker class, and the dependency checker class, and has a using relationship with the command assembler class.

6. The computer system of claim 5 wherein the processing configuration class, the candidate collector class, the dependency checker class, the currency checker class, and the command assembler class are extensible classes of the framework, the implementation of which by a user defines the at least one processing configuration.

7. The computer system of claim 1 wherein the framework defines a candidate collector class comprising:

at least one candidate collector object; and

a second set of object methods that determine a set of initial candidate modules for processing.

8. The computer system of claim 7 wherein the framework further defines a dependency checker class, a currency checker class, and a command assembler class.

9. The computer system of claim 8 wherein the candidate collector class, the dependency checker class, the currency checker class, and the command assembler class are extensible classes of the framework, the implementation of which by a user defines at least one native processing tool for processing the at least one source code module.

10. The computer system of claim 1 wherein the framework defines a dependency checker class comprising:

at least one dependency checker object; and

a third set of object methods that determine a set of all candidate modules for processing.

11. The computer system of claim 10 wherein the framework further defines a candidate collector class, a currency checker class, and a command assembler class.

12. The computer system of claim 11 wherein the candidate collector class, the dependency checker class, the currency checker class, and the command assembler class are extensible classes of the framework, the implementation of which by a user defines at least one native processing tool for processing the at least one source code module.

13. The computer system of claim 1 wherein the framework defines a currency checker class comprising:

at least one currency checker object; and

a fourth set of object methods that determine a set of candidate modules for processing that are out of date.

14. The computer system of claim 13 wherein the framework further defines a candidate collector class, a dependency checker class, and a command assembler class.

15. The computer system of claim 14 wherein the candidate collector class, the dependency checker class, the currency checker class, and the command assembler class are extensible classes of the framework, the implementation of which by a user defines at least one native processing tool for processing the at least one source code module.

16. The computer system of claim 1 wherein the framework defines a command assembler class comprising:

at least one command assembler object; and

a fifth set of object methods that determine a set of commands for processing the at least one source code module.

17. The computer system of claim 16 wherein the framework further defines a candidate collector class, a dependency checker class, and a currency checker class.

18. The computer system of claim 17 wherein the candidate collector class, the dependency checker class, the currency checker class, and the command assembler class are extensible classes of the framework, the implementation of which by a user defines at least one native processing tool for processing the at least one source code module.

19. The computer system of claim 1 wherein the framework comprises:

at least one processing configuration object that defines at least one processing configuration, the processing configuration object including a first set of object methods to collect a list of candidate source code modules including the at least one source code module, to check the dependencies of the at least one source code module to other modules in the source code program, to check the currency of the at least one source code module, and to assemble commands for the processing configuration to cause the at least one source code module to be processed;

at least one candidate collector object including a second set of object methods that determine a set of initial candidate modules for processing;

at least one dependency checker object including a third set of object methods that determine a set of all candidate modules for processing from the set of initial candidate modules;

at least one currency checker object including a fourth set of object methods that determine a set of candidate modules for processing that are out of date from the set of all candidate modules; and

at least one command assembler object including a fifth set of object methods that determine a set of all commands for processing the at least one source code module.

20. The computer system of claim 2 wherein the main memory contains an application program that supports an object oriented programming environment containing the framework, and wherein the framework is extended by providing information that implements the at least one processing configuration.

21. The computer system of claim 1 wherein the framework comprises:

core functions defined by at least one core class, wherein the implementation of the core functions is defined by the framework and cannot be modified by a user of the framework; and

extensible functions defined by at least one extensible class, wherein the implementation of the extensible functions is defined by the user of the framework by extending the at least one extensible class.

70. The computer system of claim 1 wherein the framework processes the at least one source code module for execution on a plurality of platforms.

22. A method for processing at least one source code module within a source code program, the method comprising the steps of:

providing an extensible object oriented framework mechanism that performs the processing of the at least one source code module according to extended portions of the framework mechanism that are customized to provide a desired processing configuration; and

executing the object oriented framework mechanism on a computer system.

23. The method of claim 22 further including the step of:

extending the framework mechanism to define the desired processing configuration.

24. The method of claim 22 further including the steps of:

selecting at least one target platform;

selecting at least one processing platform;

implementing at least one processing tool native to the at least one processing platform by defining the extended portions; and

implementing the desired processing configuration by defining the extended portions in accordance with the selected at least one target platform and the selected at least one processing platform.

25. The method of claim 24 further including the steps of:

selecting at least one library platform;

selecting at least one development platform;

the step of implementing the desired processing configuration including the step of defining the extended portions in accordance with the selected at least one library platform and the at least one development platform.

26. The method of claim 25 further including the steps of:

determining an initial set of candidate modules within the source code program;

determining a second set of modules within the source code program that are dependent upon the initial set of candidate modules;

determining a third set of modules within the source code program, the third set comprising the modules within the second set that are out of date;

determining a fourth set of modules that comprise the modules to be processed, and

determining a set of commands needed to process the modules within the fourth set.

27. The method of claim 26 further including the steps of:

distributing the set of commands across a plurality of computer systems;

each of the plurality of computer systems processing its respective commands to process the modules within the fourth set.

28. The method of claim 26 wherein the step of determining the initial set of candidate modules includes the step of creating an initial list of the candidate modules.

29. The method of claim 26 wherein the step of determining the second set of modules includes the step of creating a dependency list containing all modules within the source code program that may require processing in order to process the candidate modules within the initial list.

30. The method of claim 26 wherein the step of determining the third set of modules includes the step of creating an out of date list of modules within the dependency list that require processing in order to process the candidate modules within the initial list.

31. The method of claim 26 further including the steps of:

storing at least one of the processed modules in a library platform; and

moving at least one of the processed modules to a target platform.

71. The method of claim 22 further comprising the step of:

the framework mechanism processing the at least source code module for execution on a plurality of platforms.

32. A program product comprising:

a framework mechanism for source code processing, the framework mechanism including an extensible source code processing system that performs source code processing according to extended portions of the framework mechanism, the framework mechanism comprising at least one extensible class; and

signal bearing media bearing the framework mechanism.

33. The program product of claim 32 wherein the signal bearing media comprises recordable media.

34. The program product of claim 32 wherein the signal bearing media comprises transmission media.

35. The program product of claim 32 wherein the framework defines a processing configuration class comprising:

at least one processing configuration object that defines at least one processing configuration; and

a first set of object methods to collect a list of candidate source code modules including the at least one source code module, to check the dependencies of the at least one source code module to other modules in the source code program, to check the currency of the at least one source code module, and to assemble commands for the processing configuration to cause the at least one source code module to be processed.

36. The program product of claim 35 wherein the first set of object methods in the processing configuration class includes at least one method to distribute the source code processing to at least one external computer system.

37. The program product of claim 35 wherein the framework further defines a candidate collector class, a dependency checker class, a currency checker class, and a command assembler class, and wherein the processing configuration class has a “

has a”

relationship with each of the candidate collector class, the currency checker class, and the dependency checker class, and has a using relationship with the command assembler class.

38. The program product of claim 37 wherein the processing configuration class, the candidate collector class, the dependency checker class, the currency checker class, and the command assembler class are extensible classes of the framework, the implementation of which by a user defines the at least one processing configuration.

72. The program product of claim 32 wherein the framework mechanism processes the at least one source code module for execution on a plurality of platforms.

39. An apparatus having a memory containing an object oriented framework mechanism, the framework mechanism comprising:

at least one candidate collector object including a second set of object methods that determine a set of initial candidate modules for processing;

at least one dependency checker object including a third set of object methods that determine a set of all candidate modules for processing from the set of initial candidate modules;

at least one currency checker object including a fourth set of object methods that determine a set of candidate modules for processing that are out of date from the set of all candidate modules; and

at least one command assembler object including a fifth set of object methods that determine a set of all commands for processing the at least one source code module.

40. The object oriented framework mechanism of claim 39 wherein the framework mechanism further defines a processing configuration class that has a “

has a”

relationship to each of the candidate collector class, the dependency checker class, and the currency checker class, and that has a using relationship with the command assembler class.

41. The object oriented framework mechanism of claim 39 wherein the framework comprises:

core functions defined by at least one core class, wherein the implementation of the core functions is defined by the framework and cannot be modified by a user of the framework; and

extensible functions defined by at least one extensible class, wherein the implementation of the extensible functions is defined by the user of the framework by extending the at least one extensible class.

42. A method for performing source code processing of at least one source code module within a source code program, the method comprising the steps of:

(A) providing at least one processing configuration object that defines at least one processing configuration, the processing configuration object including a first set of object methods to effect the processing of the at least one source code module;

(B) providing at least one candidate collector object including a second set of object methods that determine a set of initial candidate modules for processing;

(C) providing at least one dependency checker object including a third set of object methods that determine a set of all candidate modules for processing from the set of initial candidate modules;

(D) providing at least one currency checker object including a fourth set of object methods that determine a set of candidate modules for processing that are out of date including the at least one source code module;

(E) providing at least one command assembler object including a fifth set of object methods that determine a set of all commands for processing the at least one source code module;

(F) providing an object oriented framework mechanism that comprises the at least one candidate collector object, the at least one dependency checker object, the at least one currency checker object, and the at least one command assembler object, and wherein the object oriented framework mechanism performs the processing of the at least one source code module according to extended portions of the framework mechanism that are customized to provide a desired processing configuration; and

(G) executing the object oriented framework mechanism on a computer system to process the at least one source code module.

43. The method of claim 42 further including the step of:

extending the framework mechanism to define the desired processing configuration.

44. The method of claim 42 further including the steps of:

selecting at least one target platform;

selecting at least one processing platform;

implementing at least one processing tool native to the at least one processing platform by defining the extended portions; and

implementing the desired processing configuration by defining the extended portions in accordance with the selected at least one target platform and the selected at least one processing platform.

45. The method of claim 44 further including the steps of:

selecting at least one library platform;

selecting at least one development platform;

the step of implementing the desired processing configuration including the step of defining the extended portions in accordance with the selected at least one library platform and the at least one development platform.

46. The method of claim 45 further including the steps of:

determining an initial set of candidate modules within the source code program;

determining a second set of modules within the source code program that are dependent upon the initial set of candidate modules;

determining a third set of modules within the source code program, the third set comprising the modules within the second set that are out of date;

determining a fourth set of modules that comprise the modules to be processed; and

determining a set of commands needed to process the modules within the fourth set.

47. The method of claim 46 further including the steps of:

distributing the set of commands across a plurality of computer systems;

each of the plurality of computer systems processing its respective commands to process the modules within the fourth set.

48. The method of claim 46 wherein the step of determining the initial set of candidate modules includes the step of creating an initial list of the candidate modules.

49. The method of claim 46 wherein the step of determining the second set of modules includes the step of creating a dependency list containing all modules within the source code program that may require processing in order to process the candidate modules within the initial list.

50. The method of claim 46 wherein the step of determining the third set of modules includes the step of creating an out of date list of modules within the dependency list that require processing in order to process the candidate modules within the initial list.

51. The method of claim 46 further including the steps of:

storing at least one of the processed modules in a library platform; and

moving at least one of the processed modules to a target platform.

52. A program product comprising:

(A) an object oriented framework mechanism for processing at least one source code module within a source code program, the object oriented framework mechanism comprising at least one extensible class, the object oriented framework mechanism including at least one processing configuration object that defines at least one processing configuration, the processing configuration object including a first set of object methods to effect the processing of the at least one source code module, the object oriented framework mechanism further including at least one candidate collector object, the candidate collector object including a second set of object methods that determine a set of initial candidate modules for processing, the object oriented framework mechanism further including at least one dependency checker object including a third set of object methods that determine a set of all candidate modules for processing from the set of initial candidate modules, the object oriented framework mechanism further including at least one currency checker object including a fourth set of object methods that determine a set of candidate modules for processing that are out of date, the object oriented framework mechanism further including at least one command assembler object including a fifth set of object methods that determine a set of all commands for processing the at least one source code module, wherein the object oriented framework mechanism performs the processing of the at least one source code module according to extended portions of the framework mechanism that are customized to provide a desired processing configuration; and

(B) signal bearing media bearing the object oriented framework mechanism.

53. The program product of claim 52 wherein the signal bearing media comprises recordable media.

54. The program product of claim 52 wherein the signal bearing media comprises transmission media.

55. The program product of claim 52 wherein the first set of object methods in the processing configuration class includes at least one method to distribute the source code processing to at least one external computer system.

56. The program product of claim 52 wherein the framework further defines a candidate collector class, a dependency checker class, a currency checker class, and a command assembler class, and wherein the processing configuration class has a “

has a”

relationship with each of the candidate collector class, the currency checker class, and the dependency checker class, and that has a using relationship with the command assembler class.

57. The program product of claim 56 wherein the processing configuration class, the candidate collector class, the dependency checker class, the currency checker class, and the command assembler class are extensible classes of the framework, the implementation of which by a suer defines the at least one processing configuration.

58. An apparatus having a memory containing an object oriented framework mechanism that performs source code processing of at least one source code module within a source code program, the framework mechanism comprising:

at least one core class wherein the implementation of the core class is defined by the framework and cannot be modified by a user of the framework; and

at least one extensible class wherein the implementation of the extensible class is defined by the user of the framework, by extending the at least one extensible class, thereby defining at least one processing configuration for processing the at least one source code module.

59. The object oriented framework mechanism of claim 58 further comprising:

at least one processing configuration object that defines at least one processing configuration, the processing configuration object including a first set of object methods to collect a list of candidate source code modules including the at least one source code module, to check the dependencies of the at least one source code module to other modules in the source code program, to check the currency of the at least one source code module, and to assemble commands for the processing configuration to cause the at least one source code module to be processed;

at least one candidate collector object including a second set of object methods that determine a set of initial candidate modules for processing;

at least one dependency checker object including a third set of object methods that determine a set of all candidate modules for processing from the set of initial candidate modules;

at least one currency checker object including a fourth set of object methods that determine a set of candidate modules for processing that are out of date from the set of all candidate modules; and

at least one command assembler object including a fifth set of object methods that determine a set of all commands for processing the at least one source code module.

60. The object oriented framework mechanism of claim 59 wherein the framework mechanism further defines a candidate collector class, a dependency checker class, a currency checker class, and a command assembler class, and wherein the processing configuration class has a “

has a”

relationship with each of the candidate collector class, the currency checker class, and the dependency checker class, and that has a using relationship with the command assembler class.

61. The object oriented framework mechanism of claim 58 wherein the main memory contains an application program that supports an object oriented programming environment containing the framework, and wherein the framework is extended by providing information that implements the at least one processing configuration.

62. A method for processing at least one source code module within a source code program using a computer system having a central processing unit and a main memory, the main memory having an application program that provides an object oriented programming environment, the method comprising the steps of:

(A) providing in the application program an object oriented framework mechanism that performs the processing of the at least one source code module according to extended portions of the framework mechanism that are customized to provide a desired processing configuration, the framework mechanism including;

a set of core functions wherein the implementation of the core functions is defined by the framework and cannot be modified by a user of the framework mechanism; and

a set of extensible functions wherein the implementation of the extensible functions is defined by the user of the framework mechanism;

(B) extending the extensible functions in the framework mechanism to define particular objects having predetermined protocols and defining particular object methods that perform the processing of the at least one source code module, the extensible functions defining the desired processing configuration;

(C) generating an executable source code processing system by integrating together the extensible functions and the core functions; and

(D) executing the executable source code processing system on the computer system to perform the processing of the at least one source code module.

63. The method of claim 62 further including the steps of:

selecting at least one target platform;

selecting at least one processing platform;

selecting at least one library platform;

selecting at least one development platform;

implementing at least one processing tool native to the at least one processing platform by defining the extended portions;

implementing the desired processing configuration by defining the extended portions in accordance with the selected at least one target platform, the selected at least one processing platform, the selected at least one library platform, and the selected at least one development platform;

determining an initial set of candidate modules within the source code program by creating an initial list of the candidate modules;

determining a second set of modules within the source code program that are dependent upon the initial set of candidate modules by creating a dependency list containing all modules within the source code program that may require processing in order to process the candidate modules within the initial list;

determining a third set of modules within the source code program, the third set comprising the modules within the second set that are out of date by creating an out of date list of modules within the dependency list that require processing in order to process the candidate modules within the initial list;

determining a fourth set of modules that comprise the modules to be processed;

determining a set of commands needed to process the modules within the fourth set;

processing the set of commands to process the at least one source code module in the fourth set;

storing at least one of the processed modules in a library platform; and

moving at least one of the processed modules to a target platform.

64. The method of claim 63 wherein the step of processing the set of commands includes the steps of:

distributing the set of commands across a plurality of computer systems; and

each of the plurality of computer systems processing its respective commands to process the modules within the fourth set.

65. A program product comprising:

an object oriented framework mechanism for processing at least one source code module within a source code program, the framework mechanism including at least one core class wherein the implementation of the core class is defined by the framework and cannot be modified by a user of the framework, the framework mechanism further including at least one extensible class wherein the implementation of the extensible class is defined by the user of the framework by extending the at least one extensible class, thereby defining a processing configuration that governs the operation of the framework mechanism; and

signal bearing media bearing the object oriented framework mechanism.

66. The program product of claim 65 wherein the signal bearing media comprises recordable media.

67. The program product of claim 65 wherein the signal bearing media comprises transmission media.

68. The program product of claim 65 wherein the framework comprises:

at least one processing configuration object that defines at least one processing configuration, the processing configuration object including a first set of object methods to effect the processing of the at least one source code module;

at least one candidate collector object including a second set of object methods that determine a set of initial candidate modules for processing;

at least one dependency checker object including a third set of object methods that determine a set of all candidate modules for processing from the set of initial candidate modules;

at least one currency checker object including a fourth set of object methods that determine a set of candidate modules for processing that are out of date;

at least one command assembler object including a fifth set of object methods that determine a set of commands for processing the at least one source code module;

wherein the object oriented framework mechanism performs the processing of the at least one source code module according to extended portions of the framework mechanism that are customized to provide a desired processing configuration.

69. The program product of claim 68 wherein the first set of object methods in the processing configuration class includes at least one method to distribute the source code processing to at least one external computer system.