Method of creating and using a sub-classed object that spans...

Details Method of creating and using a sub-classed object that spans... Method of creating and using a sub-classed object that spans...

2000-07-28

2004-03-30

Corrielus, Jean M. (Department: 2172)

Data processing: database and file management or data structures

Database design

Data structure types

C709S241000

Reexamination Certificate

active

06714942

ABSTRACT:

FIELD OF THE INVENTION
The present invention relates generally to object-oriented computer programs using distributed objects and, more particularly, to a distributed object architecture where an object on a local computer may create a sub-class of an object on a remote computer and thereafter function as a combined object by automatically, systematically communicating messages from the sub-class to object in a ripple up, return down fashion.
BACKGROUND OF THE RELATED ART
As stated in background section of U.S. Pat. No. 5,481,721, here paraphrased and embellished, an object is a programming unit that groups together a data structure (instance variables) and the operations (sometimes called member functions, methods, functions, or procedures) that can use or affect the data. Thus, an object consists of data and one or more operations or procedures that can be performed on that data. The joining together of data and operations into a unitary building block is called “encapsulation”. In object-oriented programming, operations that can be performed on the data are often referred to as “methods.” An object can be instructed to perform one of its operations when it receives a “message”. A message is a command or instruction to the object to execute a certain method. It consists of a method selection (name) and arguments that are sent to the object. The message does not instruct the object how to perform the method. It is only necessary to request that the object execute the method.
Object-oriented programming is being brought to the forefront because the widespread adoption of network technologies and standardized communication protocols has provided nearly universal connectivity. The result of such universal connectivity is an immense number of computers that are connected together in local area networks, or Intranets, and a global network of such networks known as the Internet. Universal connectivity exposes users and application programs to vast amounts of data, much of which is unstructured. At the same time, universal connectivity has opened the possibility of using distributed functionality when designing and writing application programs. The encapsulation of data and functionality that is inherent in the object-oriented programming paradigm has resulted in this paradigm being chosen to address the problem of distributed functionality.
There are presently two popular frameworks for distributed object computing: (1) the Distributed Component Object Model (DCOM) supported by Microsoft, and (2) the Common Object Request Broker Architecture (CORBA) supported by a consortium of hardware and software companies called the Object Management Group.
FIG. 1
shows a typical prior art approach to executing an object. In order to provide flexibility at compile time, the object's “interface” is maintained separately from the object's “implementation.” A standard mechanism such as an intermediate table relates the object's interface to the object's implementation. During compilation, the name of each member function is correlated with the corresponding binary code that implements the member function that will be invoked with the intermediate table. The intermediate table is often called a vector table, or “V-table”. The implementation consists of executable class code that is written in the developer's language of choice. Generally, because the compiler has to keep track of how the executable class code of each member function manipulates memory stacks, and the like, it is a practical necessity that all of the member functions be written in the same language at the same time. It is not practical, in other words, to provide member functions written in different languages or to modify, enhance (add functionality), or “swap-out” a member function on the fly, much less do so with an object that is distributed across a computer network or across computer languages.
An object is ultimately accessed at run-time by using a pointer to the object. The pointer contains the address of the V-Table that in turn contains more pointers (called “interfaces”) to the object's member functions. The sizes of the V-Table and executable class code are fixed when the description of the object is compiled. At runtime, an invocation of a particular member function results, with the help of the V-Table, in the execution of the corresponding code. A member function (e.g. Member Function
3
) is called by first obtaining the interface pointer for the 3
rd
interface in the V-Table whose address can be accessed from the object pointer. The interface pointer thus obtained is the memory address of the code within the object that implements Member Function
3
. If additional member functions are added to the object at a later time, then the executable class code must be recompiled and the V-table must be recreated. The executable class code implementing the member functions must be modified to include the additional member function. The V-Table must be modified to reflect the new sizes and starting locations of the member function code. When generating code for a program that will use the object, the compiler must be aware of the location within the V-Table (but not in the object itself) of the member function that is being called.
There are certain standard object functions that are desirable in an an object-oriented language:
“Function Name Overloading”
Function Name Overloading refers to situation where two member functions have the same name, but are differentiated from one another by the number of parameters, type of parameters, or both. In
FIG. 1
, for example, member function
2
and member function
3
might have the same name, but different implementations. When a compiler is generating a call to that name, the compiler will have to use the parameter list for each member function of that name to determine which V-Table entry to hardcode into the caller's code. In other words, the compiler must be aware of the location within the V-Table of the member function that is being called, and of the parameters that are used by each of the member functions when it is compiling the program that will use the object.
Inheritance
Inheritance is a mechanism for creating a new class from an existing class. The existing class is called the base class and the new class is called the derived class. In
FIG. 2
, a derived class was created that contains a new version of Member Function
4
, and a new function, Member Function
5
. The new version of Member Function
4
is said to override the version of Member Function
4
that exists in the base class. When creating code for the derived class, the compiler will create new executable code and a new interface table that contains the code and interfaces for both the base class and the derived class. The base class itself, however, will not have to be re-compiled as long as its binary representation and interface description are available.
If a second derived class is created from the same base class, and this derived class also overrides Member Function
4
, then there are now two derived classes, each with its own version of Member Function
4
. Note that the first three entries in the V-Tables for the two derived classes would be the same, while the entry in the V-Table for Member Function
4
will be in the same relative location in the V-Tables. A caller calling a member function can use the same method invocation for Member Function
4
for either of the derived classes, but the actual code executed will depend on which derived class is being used. The ability for different classes that are derived from the save base class to respond to the same method invocation is called polymorphism.
Prior distributed object architectures require some method of remote invocation in order to permit one computer (client) to interact with an object located on another computer (server). The known distributed object architectures are overly complex because the objected-oriented languages like C++ have their roots in conventional programming languages li

Affiliated with

Also associated with

Rating

Method of creating and using a sub-classed object that spans... does not yet have a rating. At this time, there are no reviews or comments for this patent.

If you have personal experience with Method of creating and using a sub-classed object that spans..., we encourage you to share that experience with our LandOfFree.com community. Your opinion is very important and Method of creating and using a sub-classed object that spans... will most certainly appreciate the feedback.

Rate now

Comments { 0 }

Profile ID: LFUS-PAI-O-3268946