Data processing: software development – installation – and managem – Software program development tool – Translation of code
Reexamination Certificate
1996-07-11
2001-07-17
Powell, Mark R. (Department: 2122)
Data processing: software development, installation, and managem
Software program development tool
Translation of code
C707S793000, C709S241000
Reexamination Certificate
active
06263485
ABSTRACT:
RELATED APPLICATIONS
The following related U.S. applications are hereby incorporated by reference: U.S. application Ser. No. 08/678,681 entitled “Method and Apparatus Using Parameterized Vectors For Converting Interface Definition Language-Defined Data Structures into a Transport and Platform Independent Format” by A. Schofield, filed Jul. 11, 1996; U.S. application Ser. No. 08/678,298 entitled “Data Structure Representing An Interface Definition Language Source File” by A. Schofield, filed Jul. 11, 1996; U.S. application Ser. No. 08/680,203 entitled “Method and Apparatus for Transporting Interface Definition Language-Defined Data Structures Between Heterogeneous Systems” by A. Schofield, filed Jul. 11, 1996, now U.S. Pat. No. 5,860,072; U.S. application Ser. No. 08/678,295 entitled “Method and Apparatus for Performing Distributed Object Calls” by A. Schofield filed Jul. 11, 1996; U.S. application Ser. No. 08/680,202 entitled “Method and Apparatus for Asynchronously Calling and Implementing Objects” by A. Schofield, filed Jul. 11, 1996; U.S. application Ser. No. 08/680,266 entitled “Method and Apparatus for Performing Distributed Object Calls using Proxies and Memory Allocation” by A. Schofield filed Jul. 11, 1996.
BACKGROUND OF THE INVENTION
1. Field of the Invention
The present invention relates to a method and apparatus for describing an interface definition language-defined interface, operation, and data type. In particular, data types are described using a series of ASCII characters.
2. Background
Distributed object computing combines the concepts of distributed computing and object-oriented computing. Distributed computing consists of two or more pieces of software sharing information with each other. These two pieces of software could be running on the same computer or on different computers connected to a common network. Most distributed computing is based on a client/server model. With the client/server model, two major types of software are used: client software, which requests the information or service, and server software, which provides or implements the information or service.
Object-oriented computing is based upon the object model where pieces of code called “objects”—often abstracted from real objects in the real world—contain data and may have actions (also known as “Operations”) performed on them. An object is defined by its interface (or “class” in C++ parlance). The interface defines the characteristics and behavior of a kind of object, including the operations that can be performed on objects of that interface and the parameters to that operation. A specific instance of an object is identified within a distributed object system by a unique identifier called an object reference.
In a distributed object system, a client application sends a request (or “invocation” or “object call”) to a server application containing an indication of the operation to be performed on a specific object, the parameters to that operation, the object reference for that object, and a mechanism to return error information (or “exception information”) about the success or failure of a request. The server application receives the request and carries out the request via a server “implementation.” The implementation satisfies the client's request for an operation on a specific object. The implementation includes one or more methods, which are the portions of code in the server application that actually do the work requested of the implementation. If the implementation is carried out successfully, the server application returns a response to the client, if necessary. The server application may also return exception information.
To standardize distributed object systems, the Object Management Group (“OMG”), a consortium of computer software companies, proposed the Common Object Request Broker Architecture (“CORBA”). Under the CORBA standard, an Object Request Broker (“ORB”) provides a communication hub for all objects in the system passing the request to the server and returning the response to the client. Commercial ORB's are known in the art and a common type is IBM's System Object Model (“SOM”). On the client side, the ORB handles requests for the invocation of a method and the related selection of servers and methods. When an application sends a request to the ORB for a method to be performed on an object, the ORB validates the arguments contained in the request against the interface for that object and dispatches the request to the server, starting it if necessary. On the server side, the ORB uses information in the request to determine the best implementation to satisfy the request. This information includes the operation the client is requesting, what type of object the operation is being performed on, and any additional information stored for the request. In addition, the server-side ORB validates each request and its arguments. The ORB is also responsible for transmitting the response back to the client.
Both the client application and the server application must have information about the available interfaces, including the objects and operations that can be performed on those objects. To facilitate the common sharing of interface definitions, OMG proposed the Interface Definition Language (“IDL”). IDL is a definition language (not a programming language) that is used to describe an object's interface; that is, the characteristics and behavior of a kind of object, including the operations that can be performed on those objects.
IDL interfaces define a set of operations that a client can invoke on an object. An interface can declare one or more exceptions, which indicate that an IDL operation did not perform successfully. Operations may receive parameters and return a return value. Each parameter to an operation may have a “direction” that indicates whether the value is passed from client to server (“in”), from server to client (“out”), or in both directions (“inout”). The parameter also has a data type that constrains its possible values. Operations may also optionally have a “one-way” attribute, which specifies which invocation semantics the communication service must provide for invocations of a particular operation. When a client invokes an operation with the one-way attribute, the invocation semantics are “best-effort”, implying that the operation will be implemented by the server at most once. If an attempt to implement the operation fails, the server does not attempt to implement the operation again. An operation with the one-way attribute must specify a void return type and must not contain any output parameters.
Data types are used to describe the accepted values of IDL operation parameters, exceptions, and return values. IDL supports two categories of data types: basic and compound. Basic types include short integers, long integers, long long integers, unsigned long integers, unsigned short integers, floating points, double, character, boolean, and octet. Compound types include enum, string, struct, array, union, sequence, and “any” types. The struct type is similar to a C structure; it lets interface designers create a complex data type using one or more type definitions. The sequence type lets interface designers pass a variable-size array of objects. The “any” type can represent any possible data type—basic or compound.
IDL is designed to be used in distributed object systems implementing OMG's (“CORBA”), Revision 2.0 specification, which is incorporated by reference herein. In a typical system implementing the CORBA specification, interface definitions are written in an IDL-defined source file (also known as a “translation unit”). The source file is compiled by an IDL compiler that generates programming-language-specific files, including client stub files, server stub files, and header files. Client stub files are language-specific mappings of IDL operation definitions for an object type into procedural routines, one for each operation. When compiled by a language-specific compiler and linked into a client application, the stub
Chavis John Q.
Powell Mark R.
Thompson & Knight LLP
LandOfFree
Method and apparatus for describing an interface definition... 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 and apparatus for describing an interface definition..., we encourage you to share that experience with our LandOfFree.com community. Your opinion is very important and Method and apparatus for describing an interface definition... will most certainly appreciate the feedback.
Profile ID: LFUS-PAI-O-2562351