System and method for creating reusable components in an object-oriented programming environment

• US 5,864,862 A
• Filed: 09/30/1996
• Issued: 01/26/1999
• Est. Priority Date: 09/30/1996
• Status: Expired due to Term

• Current Assignee: Telefonaktiebolaget LM Ericsson
• Original Assignee: Telefonaktiebolaget LM Ericsson
• Inventors: Kriens, Peter, Bjork, Bengt Hakan, Eissing, Stefan B.
• Primary Examiner(s): Black, Thomas G.
• Assistant Examiner(s): HOMERE, JEAN RAYMOND
• Application Number:
  US08/724,553
• Time in Patent Office: 848 Days
• Field of Search: 707/103, 707/101, 707/102, 395/683, 395/685
• US Class Current: 1/1
• CPC Class Codes: G06F 8/24 Object-oriented
• CPC Class Codes: Y10S 707/99942 Manipulating data structure, e.g. compression, compaction, compilation
• CPC Class Codes: Y10S 707/99943 Generating database or data structure, e.g. via user interface
• CPC Class Codes: Y10S 707/99944 Object-oriented database structure

Abstract

A novel object called the Data Object is used to represent different information types in a system in a singular way in an object-oriented programming environment. The Data Object stores the value of the information and a reference to an object that handles that specific type of information. All requests on the Data Object are forwarded to this handler. The interface allows programmers to query the structure of the information, place constraints on values and names of the parts. This makes it possible to write code that performs a service that adapts itself to whatever Data Object it gets. The use of a Data Object significantly minimizes the coupling between modules and make reusable code easier to develop because each object class in the object-oriented software system is now coupled only to the Data Object class.

Claims

1. In an object-oriented programming environment on a computer system comprising a processing unit, a memory unit, an I/O (input/output) unit and an operating system, a method for reducing the coupling between objects in the object-oriented programming environment comprising the steps of:

creating a plurality of objects, each of said objects capable of communicating with a Data Object;

selectively combining two or more of said plurality of objects to create one or more software program modules;

linking said one or more software modules with each other and with the operating system of said computer to create an executable software application program; and

executing said software application program on said computer system, said step of executing said software application program further comprising the steps of;

processing each invocation of each of said objects in said software application program through said Data Object; and

processing each interaction of each of said objects in said software application program with other objects in said software application program, with other software application programs or with the operating system of said computer through said Data Object.

2. In an object-oriented programming environment on a computer system comprising a processing unit, a memory unit, an I/O (input/output) unit and an operating system, a method for reducing the coupling between objects in the object-oriented programming environment comprising the steps of:

creating a plurality of objects, at least one of which is a Data Object;

selectively combining two or more of said plurality of objects to create one or more software program modules;

linking said one or more software modules with each other and with the operating system of said computer to create an executable software application program; and

executing said software application program on said computer system by processing communications between said plurality of objects through said Data Object.

3. In an object-oriented software system, a method for reducing the coupling between components using a Data Object as a container for passing information between said components, said Data Object being of a single object type, and having the following additional characteristics:

said Data Object being capable of holding values that are a recursive composition of a defined and small set of fundamental types;

said Data Object being amenable to efficient access and retrieval when the composition of an actual value contained in said Data Object is known;

the composition of said Data Object being capable of being queried during the execution of a software program without requiring prior knowledge of said actual value contained in said Data Object;

accesses to said actual value being delegated to an object that maintains descriptive information about the actual type and which is an instance of a meta-type class, and each fundamental type being correlated to a different class that defines the behavior of the fundamental type by implementing the applicable polymorphistic messages for that fundamental type; and

the information about the composition further containing information for using said actual value in different contexts, such information encompassing, but not being limited to, user-defined type names, constraints on said actual values and named information for accessing the descendant values that a value is composed of.

4. The method of claim 3 further comprising a technique for generalizing the description of a data definition specification whereby the same descriptive objects are used to describe the selection in a choice type, said actual value in an enumerated type, the accesses to a field in a structure, and the accesses to the bits in a bit string, said technique further defining an object type named Label, wherein the instances contain a name and a reference to a meta-type object.

5. The method of claim 3 wherein the set of fundamental types is as defined in the ASN.1 standard.

6. The method of claim 3 wherein the set of fundamental types is as defined in the OMG IDL standard.

7. An implementation in the C++ language of the method of claim 3 wherein the following characteristic is added:

the program reads an ASN.1 module definition and creates a source file for a programming system containing a function that can create the meta-type classes structure that models the appropriate module definition for the invention.

8. An implementation in the C++ language of the method of claim 3 wherein the following characteristic is added:

the program reads an IDL module definition and creates a source file for a programming system containing a function that can create the meta-type classes structure that models the appropriate module definition for the invention.

9. An implementation in the C++ language of the method of claim 3 wherein the following characteristic is added:

the program accepts a Data Object and converts said actual values to a set of SQL commands for storing the Data Object in a database.

10. An implementation in the C++ language of the method of claim 3 wherein the following characteristic is added:

the program accepts a Data Object conforming to the ASN.1 standard and prints out the contents in ASN.1 value syntax.

11. An implementation in the C++ language of the method of claim 3 wherein the following characteristic is added:

the program accepts a meta-type conforming to the ASN.1 standard and reads in an ASN.1 value from a file.

12. An implementation in the C++ language of the method of claim 3 wherein the following characteristic is added:

the program accepts a Data Object conforming to the ASN.1 standard and prints out the contents in ASN.1 Basic Encoding Rule (BER) syntax.

13. An implementation in the C++ language of the method of claim 3 wherein the following characteristic is added:

the program accepts a meta-type conforming to the ASN.1 standard and reads in an ASN.1 BER value from a file.

14. An implementation in the C++ language of the method of claim 3 wherein the following characteristic is added:

the program accepts Data Objects, keeps a plurality of them in memory and allows them to be retrieved by specifying a list of names and values matching an object present in the cache.

15. An implementation in the C++ language of the method of claim 3 wherein the following characteristic is added:

a user interface program that accepts a description of the requested user interface in a data unit and interfaces with the application using data units, where all components in the user interface are capable of receiving and sending Data Objects.

16. An implementation in the C++ language of the method of claim 3 wherein the following characteristic is added:

a user interface program that accepts a meta-type object and creates a graphic user interface program that can view and edit any Data Object associated with that meta-type.

17. An implementation in the C++ language of the method of claim 3 wherein the following characteristic is added:

a program that accepts a list of Data Objects and can sort these objects in the order as defined by a list of labels.

18. An implementation in the C++ language of the method of claim 3 wherein the following characteristic is added:

a program that converts a Data Object conforming to the OMG IDL specification to an IDL structure and vice versa.