CA2200091A1 - System and method for providing interoperability among heterogeneous object systems - Google Patents

Abstract

A system and method in accordance with a preferred embodiment enable objects from two or more heterogeneous object systems in a digital computer to interoperate and be combined in the creation of a larger object-oriented software project, as well as uses of such system and method. Objects from a foreign object system are unmodified, yet appear to be native to the object system in which they are used or accessed. A native proxy object (indistinguishable from other native objects) is constructed for the real foreign object. The proxy object contains an identifier to the real object, as well as a pointer to a software description of how to access and manipulate the object - e.g. how to call its methods, set its properties, and handle exceptions. When the proxy object is manipulated, it follows the instructions in the software description which, in turn, results in the corresponding manipulation of the foreign object.

Description

WO 96/08765 PCI/C~gS/00S~3 SYSTEM AND METHOD FOR PRO~IDING INTEROPERABIl~ITY AMONG
HETERO~ :u~; OB~ T ~ tsMS
Tf~hn; t'Al F; ~1~1 The present invention relates to object-oriented software systems and related me~hoA~ for digital computers.
- R~t~k-rr- lln-l Art Using object-oriented software techniques, software applications for digital computers are created by combining 10 software objects. To facilitate this process, object-oriented software systems typically provide an architecture specification, called the object model, which enables all objects developed to the specification to work together seamlessly in an application. Examples of object models 15 would include the Object Management Group's Common Object Request Broker Architecture (CORBA), and Microsoft~s Common Object Model (COM.) Such systems also typically provide software, called the object system, which implements the basic features provided for in the object model.
There are numerous object systems, some very general in nature such as Microsoft's Object Linking and Embedding (OLE) (which follows the COM object model;, or IBM~s Distributed System Object Model (DSOM), and Iona's O~BIX, (which both follow the CORBA object model). See for 25 ~O~le: the OLE 2 Progr~mmers Reference, Volume 1 and 2, Microsoft Press, 1994; the IBM SOMobjects Developer Toolkit V2.0, ~royL~-u-.crs Reference Manual, 1993; Iona ORBIX, Advanced Programmers Guide, 1994; and The Common Object Request Broker: Architecture and Specification Ch. 6., OMG, 1991; these references are hereby incorporated herein by reference.
Other object systems are designed to provide specific functionality, for example, in areas such as groupware or relational database - e.g. Lotus Notes. Still other object 35 systems are specific to particular to applications - e.g.
Sl~STl~UTE SHEET (RULE 26) wog6/0~65 ~n~ ~ PCTICAgS/~S13 Novell's AppWare Bus, Hewlett Packard's Broadcast Message Server, and Microsoft Visual Basic's VBX object mechanism.
See for example: the Lotus Notes Programmers Reference Manual, 1993; the Novell Visual AppBuilder Programmers 5 Reference Manual, 1994; the Hewlett Packard Softbench BMS, Programmers Reference Manual, 1992; and Microsoft Visual Basic 3.0 Professional Features Book 1, Control Development Guide, 1993; these references are also hereby incorporated herein by reference.
In creating a software application it is desirable to combine objects from various object systems, because different object systems are best suited to different tasks, and because the best solution is usually built from the best parts (i.e. objects.) However, objects from various object systems don't naturally work together for a number of reasons.
Object systems are rendered incompatible due to differences in the means by which objects are created, methods are called and properties are set in each object system, including differences in the fundamental mechanisms used as well differences in low-level calling conventions such as the physical layout of types and classes. For example at the fundamental level, some object systems, such as COM, use direct C++ calling mechanisms. Others such as 25 DSOM pre-process source code so that in place of a direct call, a function from the object system is called which, in turn, returns a pointer to the real method. This pointer is dereferenced to actually call the method. Still other object systems such as OLE Automation provide specialized functions developers must use to call methods (this is often referred to as a Dynamic Invocation Interface or DII). These functions take the method to be called as an argument, as well as the method's arguments (usually packed into a particular format), and they call the method for the 35 developer. There are numerous other broad differences and 7 ~
W096/0~65 PCT/C~9~0513 variants in fundamental calling mechanisms. Each of these fundamental mechanisms also differ in detail. For example, CORBA requires an environment pointer argument (and has an optional context argument), while other object systems do 5 not.
In addition to the vast differences in fundamental calling mechanisms, there are many differences in low-level calling conventions, sometimes referred to as procedure calling conventions. For example, different object systems l0 handle the return value from methods differently when the type of the return value is a float or a structure. In one case the value may be returned on the processor stack, while in another the value may be placed in a register. Thus, using the return value of a method from a different object system would result in an error. Other examples of differences in procedure calling conventions would include how structures are packed into memory, and how arguments are placed on the stack.
Various object systems also support various types which 20 may not be compatible with other object systems. Simple examples of types include language types such as integers, floats, etc. More complex language types include arrays, stri~gs, and objects. There are also semantic types such as "variable types" like the CORBA Any, and the COM VARrANT.
Semantic types differ from language types in that they have a particular semantic meaning to the system. While certain semantic types may conceptually mean the same thing among various object systems, their co~responding language representation and implementation may be entirely different.
30 A common example is strings. In COM, strings are represented using a "BSTR" ~a non-NULL terminated string which contains length information), while in CORBA, strings are the traditional C language byte array (NULL terminated with no length information). As a result, a COM object couldn't pass a BSTR to a CORBA object because any functions W096/08765 ~ ~ O O O 9 ~ PCT/CAg51~513 that operate on strings, such as copying and comparison, used in the CORBA object would fail. Likewise, while variable types" such as the CORBA Any and the COM VARIANT
~mean'~ the same thing, they aren't compatible.
In addition, object systems have various rules about lifecycle management which may be incompatible. The term lifecycle management refers to the process required when creating, storing, and deleting objects. For example, COM
requires developers to perform reference counting so objects can be automatically deleted. Relational databases have much more sophisticated lifecycle management, while CORBA
has only very simple lifecycle management with no reference counting.
The above issue of lifecycle management is challenging 15 because often, objects are passed as arguments to methods.
Consider the case where an object in one object system calls a method of an object in a foreign object system and passes an object (from its object system) in as an argument to the method. Since the foreign object system only understands its own objects, the object argument must be dynamically converted to a corresponding object in the foreign object system. In other words, a new object must be created in the foreign object system to match the original object passed in as an argument. All such dynamic lifecycle management -object creation, with its corresponding object destruction -must be handled properly if object system interoperability is to work.
Another aspect of object system interoperability is differences in exception and error handling among object systems. Errors or exceptions encountered within the code for an object typically must also be dealt with in the object which called the code. If the two objects are from different object systems, and the error handling mechanisms are incompatible, software failure may result.
Various object systems provide different ways to Wos6/o876~ PCTICA9S/00513 _ 5 dynamically query for information about objects. This functionality is required for object systems that provide a general macro script recording facility as well as for object systems that provide distributed computing capabilities. See for example Ch. 1-3 of Microsoft's OLE 2 Programmers Reference Volume 2, Apple's Inside Macintosh:
Interapplication Communication Ch. 8 (hereby incorporated herein by reference), or the Object Management Group's The Common Object Request Broker: Architecture and Specification l0 Ch. 6. Thus, incompatibilities in the mechanisms to query for information about objects results in significant restrictions in the ways that objects may be used in other object systems.
As mentioned previously, object systems each have 15 different design goals. As a result, each typically has functionality that isn't available in other object systems.
Two examples of this are: CORBA namespaces (which COM
doesn't have); and COM objects supporting multiple interfaces (which CORBA doesn't have). Software errors can result if an object is asked to perform some action that is only available in another object system.
In summary then, a sought after goal has been to provide interoperability among various object systems.
Different object systems place different requirements on objects, so specialized software systems are required to enable interoperability. The prior art includes approaches to providing interoperability between object systems. Three solutions are of interest: stub function wrappers; a common wire protocol; and dynamic converters.
With the stub function wrapper method, an automated tool is used to generate stub functions which "wrap" objects in code that follows the specification of another object model. That is, the tool creates an object class in the foreign object system that contains only the code necessary to forward requests to the native object. This "stub" code W096/~65 2 ~ PCT/CAgS/~S13 is then compiled and linked into an application . The stub function method is exemplified by the COM interoperability provided with IBM's DSOM for Windows. Using it, developers who have DSOM objects and want to use them from within COM
5 use an automatic tool to generate source code for corresponding COM objects. The source code for the COM
objects is simply a set of stub functions which forward calls to DSOM. For example, when the COM application calls a method of the COM object, the method simply re-calls the 10 DSOM version of the method.
One automated tool to create a set of stub function wrappers provides one-way interoperability between two object systems. To provide two-way interoperability - as is required for dynamiç lifecycle management, a second tool has to be written. If an additional object system is to be supported, and full interoperability among all three systems is required, an additional four automated tools must be written. In fact, the number of such tools required for interoperability among N object systems is N2-N In 20 addition, for each object class, N2-N versions of stub wrapper functions must be generated, managed and supported.
Given that any particular application will have hundreds of classes, this is a significant disadvantage. Furthermore, this method provides no support for the remainder of interoperability issues such as dealing with type conversions, low level calling convention differences, lifecycle management differences, differences in error and exception handling, querying, or functionality differences.
As a result, users of the object must code such conversions into their software manually, making it apparent that the object is from another object system (i.e. the object is clearly not indistinguishable from native object.)' Finally, support for new object systems is not dynamic, so code must be recompiled and relinked.
Dynamic converters are designed to provide interoperability between two object systems that both support a dynamic invocation interface (DII ) . A DII
"dynamically invokes" methods. That is, a DII is a set of functions that will call an object's methods for the developer dynamically, and pass arguments to the methods using a pre-defined convention, rather than requiring that the call be compiled into the application. A dynamic converter is a hard-coded map between two DIIs. When a method is called, the converter code packages the information into a format suitable for the DII of the second object system, then calls the method.
AS with the stub wrapper mechanism, this approach requires N2-N converters in order to support N object systems. Furthermore, dynamic converters onlY work with 15 object systems that support a DII. Moreover because they use a DII their performance suffers. And, as with the stub wrapper methodt this method provides no general support for the remainder of interoperability issues such as dealing with type conversions, differences in error and exception 20 handling, querying, or functionality differences - thereby - being unable to provide foreign objects which are indistinguishable from native objects.
The common wire protocol method is designed to work with distributed object systems, that is, object systems 25 whose objects may be located on different computers having different machine architectures. With the common wire protocol method, object systems which share a common underlying distributed computing system (DCS) - the "common wire~ - can interoperate The common distributed computing system enables object systems to transfer language data types, because a non N2-N language data type transfer mechanism is provided by the DCS.
This approach addresses the issue of low level calling conventions and provides mapping of low level data types.
35 The complexity of supporting N object systems depends w096/0876~ PCT/CAsS/~13 directly upon whether the object systems share the same object model. If so, there is no need to provide interoperability between fundamental calling convention differences, semantic type differences, lifecycle management differences, differences in error and exception handling, or functionality differences, and each object system requires only to support the DCS. This case would be exemplified by interoperability among various CORBA object systems such as IBM~s DSOM, Iona's Orbix, Hewlett Packard's DOMF, etc. which can each use the Open Software Foundation's Distributed Computing Environment (DCE).
If interoperability is among object systems that don~t share a common object model, the approach requires N2-N
converters to deal with the remaining issues. Furthermore, this method doesn't work at all if the object systems which must interoperate are not built on top of a shared distributed computing system. And the approach is very resource intensive due to the reliance on a DCS. While it handles transfer of simple data types, it provides no 20 general mechanism to handle more complex type conversions, lifecycle management differences, differences in error and exception handling, querying, or functionality differences -resulting in similar deficiencies to other prior art.
Along with the above prior art directly addressing the issue of object system interoperability, there is other prior art addressing various elements of the problem, each in a different context.
There have been a number of systems that have dealt with the issue of mapping between different low-level calling conventions. In U.S. Pat. No. 4,736,321, a method was described wherein an interactive language workspace, APL, was able to call external language procedures. In it, FORTRAN functions were declared to the APL environment, and the APL environment mapped the APL calls and arguments into FORTRAN calling conventions. The method in this patent is wos6/0876s PCT/CA9S/OOS13 g specific to the interactive APL language environment and provides unidirectional access from APL to multiple languages (FORTRAN and Assembler). The method doesn't support bi-directional access among any number of languages, 5 and doesn't work among compiled language code systems.
A similar mechanism was described for Prolog in U.S.
Pat. No. 5,274,821 wherein a Prolog language procedure could call external language functions and vice versa. In this patent, the mapping was accomplished using a table driven approach. That is, mapping of Prolog to multiple languages, and mapping multiple languages to Prolog was accomplished by describing the low level calling convention to the system in a table. This information was used at execution time to dynamically perform the mapping. As with the method in U.S.
Pat. No. 4,736,321, this method is specific to an interactive language environment, in this case, Prolog. It provides bi-directional mapping from Prolog to N languages, but not among N languages. The method doesn't work among compiled language code systems, and in any case would require N2-N conversion tables.
A mechanism was described in U.S. Pat. No. 5,210,876 wherein an interpreter is able to call a compiled procedure, which in turn, calls an interpreted procedure. The means was to generate a new intermediate compiled procedure which is called by the original compiled procedure. The new compiled procedure was then dynamically linked with the original compiled procedure. The new generated procedure converted arguments to the format required by the interpreter, then called the interpreted procedure.
30 Finally, the results were converted back to those required by the compiled language. As with other prior art, this patent facilitates an interpreted environment calling compiled language code. And as with other prior art, N2-N
code generators would be required to support procedure calling convention conversion among N systems.

W096/08765 ~ PCT/CAgS/00513 U.S. Pat. No. 5,097,533 describes a method for interfacing various pre-determined computer languages to a single software system. In it, code is written for each language to map from the API in the language to a single API
for the underlying software system. This patent maps procedure calling conventions from N languages to one by writing code to perform the mapping for each. The method does not work for conversion among N language conventions, and in any case would require N2-N code blocks to be 10 written.
In U.S. Pat. No. 5,146,593, a method is described wherein a single software interface is used to call a plurality of procedures. In fact, this is but one example of a DII - a DII designed for mapping to different 15 programming languages. In it, the method uses tables to describe the low level calling conventions of the particular language. The user (i.e. the software developer wishing to make the calls) links the DII interface with their application and uses it to make all their calls by passing it a procedure identifier, and data structures in a predefined format. The method doesn't support interoperability among N language calling conventions, and would also require N2-N tables should the approach attempt to be extended for that purpose.
The above patents share the fact that they are designed to provide a mechanism to deal with the differences between low-level calling conventions of various languages. With the exception of U.S. Pat. No. 5,210,876 they each provide a means of converting various language types as well.
However, they don't address the issue of differences between high level calling conventions. In fact, they each a provide a different high level calling convention, so they have no need to. Nor do they provide any support for mapping between semantic types.
Other patents, for example U.S. Pat. No. 5,187,787 have W096/08765 ~ i PCT/CAgS/~S13 dealt with the issue of mapping between semantic types. In this patent, mapping between semantic types was but one element of a larger system used to provide a commllnications interface which decoupled two software applications. In it, the semantic types used in the communication were designed by to be self-describing. The patent teaches that the semantic description must be separated from the data representation for interoperability. Further, developers use a system API to access data, which may be located elsewhere, and in another semantic form. Thus, the mechanism requires explicit knowledge on the part of the developer to use the decoupled data, and is analogous to a single DII, with the same consequent limitations.
In U.S. Pat. No. 5,278,978, a method was described to transfer information between two databases. As a part of the system, a mechanism was described to map between both language types and semantic types. Each language type was tagged with a canonical identifier called a marker descriptor. Likewise, separately, each semantic type was tagged with a canonical identifier called a type definition.
When data was received from another database, the descriptions were used to perform a conversion. Each database was required to have predefined descriptions of all other machine environments and semantic types, i.e. N2-N
conversion descriptions, because conversion was performed at the receiving database.
.sl~mm~ry of the Tnvention This invention provides in some embodiments a single system in a digital computer enabling software objects from 30 multiple heterogeneous object systems to interoperate bi-directionally and to be combined in the creation of a larger software system. Objects from a foreign object system are unmodified, yet appear to be native to the object system in which they are used or accessed. Support for additional 35 object systems may be added dynamically while the system is WOg6/08765 ~ ~, O ~ O 9 1 PCT/C~9S/OOS13 executing, thereby adding bi-directional interoperability with all other supported object systems. A mechanism is also provided whereby features in one object system may be supported in other object systems without the necessity of 5 modifying objects.
For a foreign object to be used in another object system, the system of these embodiments constructs a native proxy object (indistinguishable from other native objects) for the real foreign object. The proxy object contains an identifier to the real object, as well as a pointer to a software description of how to access and manipulate the object - e.g. how to call its methods, set its properties, and handle exceptions. When the proxy object is manipulated, it follows the instructions in the software description which, in turn, results in the corresponding manipulation of the foreign object.
The system of these embodiments provides a number of object-oriented frameworks with default implementations.
There are frameworks to: dynamically locate objects in an object system-specific or uniform namespace; describe the characteristics of an object class or instance; describe both semantic and language types; "execute" the software descriptions to forward manipulations of the proxy object to the real foreign object; handle errors and exceptions;
create, copy, destroy, and manage the lifecycle of objects;
and a framework to "export" object definitions - i.e. to make objects in one object system appear as object classes indistinguishable from native obiect classes temporarily or permanently in other object systems.
In addition, there is a framework to add extra information to the description of any object class. Such added information is called a "mixin". When an object is manipulated in a way it doesn't support, for example if it is asked to return the middle element of a collection but it doesn't support such a method, the system asks the mixins W096/0~65 ~ i PCT/CAgS/OOS13 associated with the object if they can support the request.
If so, they take over and perform the request. In this way, a general mechanism is provided to extend the capabilities .
of objects in an object system with features of other object systems that they wouldn't naturally support.
Extensions to the default implementations of each of the above frameworks are grouped by object system, and packaged into libraries called Object System Adapters (OSAs). OSAs can be dynamically loaded into the OSA
10 Registry framework of the system, thus adding everything necessary to dynamically support new object systems and provide full interoperability with other object systems.
It will be obvious to those skilled in the art that the system may be used stand-alone, or embedded as an element of 15 a larger software system.
Further embodiments of the invention are also provided-(A) a system and method to enable the creation of a Uuniversal object", i.e. a single object which appears to be implemented in a plurality of object systems simultaneously, 20 and which can dynamically change which object systems it supports. Said system also enables the creation of objects in individual, application, and server configurations.
Further, such objects may be based upon interpreted or compiled language technology;
(B) a system and method - either library-based or interactive - to enable the construction of object classes including the aforementioned "universal object", where such system in the creation of said object classes, may constitute a subclass of, incorporate, or embed instances 30 of, objects from a plurality of object systems;
(C) a system and method to enable object classes and objects to be relocated among applications and servers in - one or more object systems while the applications and servers are executing, and without disruption of software 35 utilizing said object classes and objects, even if it too is WO96~M65 ; rcT/cAssl~l3 executing.
Brief Description of the Drawinqs The foregoing aspects of the invention may be more readily understood by reference to the following detailed description, furnished in connection with the following drawings, in which:
FIG. 1 iB a simplified overview of a system (in use) in accordance with a preferred emhoA;ment of the invention;
FIG. 2 is an overview of the system architecture in accordance with a preferred embodiment of the invention;
FIG. 3 shows Object System Adapters of Fig. 2 plugged into the Adapter Registry Framework;
FIG. 4 shows the description of a class with one method and one property in accordance with the embodiment of Fig. 2;
FIG. 5 shows a nested type description in accordance with the embodiment of Fig. 2;
FIG. 6 shows the description of a method which follows the CORBA C language calling convention;
FIG. 7 shows the description of a similar method which is called using a Dynamic Invocation Interface;
FIG. 8 shows the typical lifecycle of an object;
FIG. 9 shows the process used to expose classes using the system of Fig. 2;
FIG. 10 shows a typical proxy object in accordance with the emhodiment of Fig. 2;
FIG. 11 shows individual, application, and server configurations of "universal objects" in accordance with a preferred embodiment of the invention;
FIG. 12a illustrates an example of the system wos6~876sPCT/CA9S/~Sl3 - 14a -enabling a universal object in an individual configuration; and FIGS. 12b and 12c illustrate application and server configurations respectively.
Detailed DescriDtion of S~ecific Embodiments Fig. 1 shows a simplified overview of the system 105 in use in a digital computer in accordance with a preferred embodiment of the invention. Process 101 is implemented using a first object system, referred to as the "native" object system, distinct from a second object system in which WO 96/0876S ~ PCT/CA9S/OOS13 process 102, and object 103 are implemented. The second object system, implementing process 102 and object 103, is referred to as the ~foreign~ object system (foreign relative to the process 101 which is using the object 103). The system 105 has constructed a proxy object 100. The proxy object 100 appears indistinguishable from other objects lmplemented using the native object system in process 101.
The proxy object 100 established by system 105 contains a pointer to the real object 103, as well as to a software description 104, of how to access and manipulate the real obiect 103 - e.g. how to call its methods, set its properties, and handle exceptions. When process 101 manipulates proxy object 100, the manipulations are intercepted by the system and forwarded to the real object 103. The system forwards the manipulation by following the instructions in the software description 104, which, in turn, results in the corresponding manipulation of the real object 103. The system can follow the instructions in the software description 104 regardless of which object system created it, thus resulting in a non-N2-N approach to object system interoperability.
Referring to Fig. 2, there is shown a simplified architecture diagram of the system in accordance with a preferred embodiment of the invention. As described below, applicants have successfully implemented this embodiment on a wide range of hardware platforms in a wide range of object systems. In the diagram, the triangular symbol 110 indicates that items to its right are subclasses. The system includes nine frameworks as follows:
the Location and Enumeration Framework 1 to dynamically locate objects in an object system-specific or uniform namespace. Included in this framework is the ability to determine the characteristics of objects that have been located;

WO ~/08765 ~ rcTlcAg5 ~ l3 ~ the Class Description Framework 2 to provide a description of the characteristics of an object class or instance;
the Type Description Framework 3 to provide a description of and to convert both semantic and language types;
the Forwarding Engine Framework 4 to "execute" the software descriptions to forward manipulations of the proxy object to the real foreign object;
the Error and Exception Handling Framework 5 to handle errors and exceptions;
the Lifecycle Management Framework 6 to create, copy, destroy, and manage the lifecycle of objects; and the Object Exporting Framework 7 to "export" object definitions - i.e. to make objects in one object system appear as object classes indistinguishable from native object classes temporarily or permanently in other object systems.
In addition, there is the Mixin Support Framework 8 to add extra information to the description of any object class, enabling the support in all object systems of features found only in one object system. There is also the OSA Registry Framework 9 to load, unload, and manage Object System Adapters (OSAs) 10. The OSAs 10 are libraries that package together extensions to the default implementation of each aforementioned framework provided by the system. When 25 added, they provide full bi-directional interoperability among all other object systems with corresponding OSAs loaded.
A more detailed architecture diagram may be found in the Visual Edge Software Ltd. Class Registry Functicnal Specification included herein at the end of the Detailed Description of Specific Embodiments (pages (41-143). It will be understood by those skilled in the art that the above architecture diagrams may be reorganized without affecting the utility of the embodiment described.
~BSTIME SHEE~ (RULE ~6) WO ~l08765 ~ ~ ~ ~ ~ ~ ~ PCT/CA9S ~ 13 Fig. 3 shows the OSA Registry framework 9 as well as a number of OSAs loaded. In this configuration, the system provides interoperability among the four object systems corresponding to the OSAs.
A specific embodiment of the invention has been written in C++ and runs on Microsoft Windows 3.1 and Windows NT, IBM
OS/2 and AIX, Sun Microsystems SunOS and Solaris, as well as on Hewlett Packard HP-UX. Object System Adapters have been implemented for Microsoft OLE Automation, IBM SOM and DSOM, 10 Microsoft COM, and for the Microsoft Visual Basic VBX object system. In addition, an OSA has been implemented for an interpretive language environment. The embodiment currently provides support for enabling objects implemented in pure C++ to be used in object systems with corresponding OSAs.
Likewise, the embodiment currently provides support for enabling software written in C (i.e. not written to any object system) to be used in object systems with corresponding OSAs.
The sections below describe each of the above frameworks, and the section numbers below correspond to the item numbers in Fig. 2.
1) The Location and Enumeration Framework: a framework to dynamically locate objects in an object system-specific or uniform namespace.
The Location and Enumeration framework has two primary sub-frameworks as shown in Fig. 2b, an object system-specific namespace sub-framework called an "Adapter NameSpace" 111, and an object sys~em-independent namespace sub-framework called a "View NameSpacell 112. Together, adding support in the framework for new object systems requires only that the Adapter NameSpace be subclassed - a linear (i.e. non N2-N) operation.
The Location and Enumeration Eramework provides a suite of generic capabilities which may be used by OSAs or Wo ~/0~65 ' rCT/CA~/OOS13 overridden (in the object-oriented sense) and replaced with capabilities specific to an individual object system. More specifically, the Adapter NameSpace 111 provides searching capabilities to locate a particular, or a complete list of:
classes, instances, functions, types, exceptions, sub-namespaces, or any combination therein in the object system.
It will be apparent to those skilled in the art that numerous well known search techniques, such as regular expression matching, may be applied during the search 10 process. Using object-oriented principles, a single interface - the Adapter NameSpace interface - is therefore utilized by the remainder of the system to search any particular object system to determine and return the hierarchy of information it provides.
Items in Adapter NameSpaces may be enumerated upon execution of the system or loading of the particular OSA.
More often, however, Adapter NameSpaces will not enumerate their contents until required, as would be the case if a user performed a browsing operation, if the system had to construct an object of a particular class, or if the system had to make a class visible in another object system.
Adapter NameSpaces enumerate their contents using generic mechanisms provided by the system, or by supplying object-specific mechanisms. Generic mechanisms provided by the system include static mechanisms, dynamic mechanisms, or database mechanisms. With static mechanisms, users of the system call system APIs to register their information. With dynamic mechanisms, the system queries the objects themselves (or the software utilizing the system, such as a language interpreter's symbol table) to determine the information. With database mechanisms, the system reads a file, or a repository to determine the information'.
Examples of the latter would include querying information from a CORBA interface repository, reading a COM ~ype Library, reading llheader files" (e.g. C++ header files or W096/08765 ~ ~ n ~ ~ ~ 1 PCT/C~9~/~S13 CORBA IDL files), or reading the symbol table of a "dynamic link library". Typically, each OSA would have to override some capabilities of the generic mechanisms.
The second sub-framework, View NameSpaces 112, provides 5 an object system independent mechanism to organize information such as classes, instances, types, etc. View NameSpaces, may be organized in a acyclic graph. View NameSpaces may also be subclassed to provide particular capabilities such as a flat list of named objects (i.e.
classes, instances, types, etc.). Any item enumerated in an Adapter NameSpace may be placed in a View NameSpace, including then entire NameSpace of an OSA. As is typical of file systems, aliases are provided, and circularities are recognized. In this way, users of the system have a means to fully locate and organize information in an object system independent way.

2) The Class Description Framework: a framework to describe the characteristics of an object class or instance.
Contained in Adapter and View NameSpaces is the information to describe classes. The Class Description Framework is provided to enable this capability, and to enable OSAs to override built-in functionality. The Class Description Framework consists of a suite of classes which 25 describe: classes, instances, properties, functions (including methods), arguments, and exceptions. The corresponding classes used are entitled, respectively:
VClassData, VInstanceData, VPropData, VFunctionData, VArgumentData, and VExceptionData. An additional framework to describe types, the Type Description Framework as described below, is also utilized. Each of the above classes can be asked for the name of the object it represents, its type, its owner (e.g. if it describes a class property, its owner would be the class), the object system that manages it, as well as Uusage codes" (described wos6lo876s PCT/CA9S/OOSl3 below).
The class in the Class Description Framework which is used to describe classes (as opposed to describing properties or methods) is called VClassData. VClassData 5 provides descriptions of the class it represents to the rest of the system by returning results from method calls rather than by building a static data structure, a linked list data structure, or the like. For example, it provides a class method which returns a list of properties. This enables 10 OSAs to subclass VClassData and override its methods in order to provide the class description using an object system-specific implementation, while still providing a single API to the rest of the system.
The VClassData class has methods to return, for the class it describes: the base classes (as a list of VClassData); the constructor, duplicator, and destructor (as VFunctionData); the class' methods (as a list of VFunctionData); the class' properties (as a list of VPropData); the class' exceptions (as a list of 20 VExceptionData); as well as a method to return a named instance of the class.
The class in the Class Description Framework which describes functions and class methods is called VFunctionData. The VFunctionData class has methods to return, for the function it describes: the arguments (as a list of VArgData), the exceptions the function can throw (as a list of VExceptionData), and a callable entry point for the function (or method).
The class in the Class Description Framework which 30 describes class properties is called VPropData. The VPropData class has methods to return, for the property it describes: a method to set the property, as well as a method to get the property (both as VFunctionData).
Likewise, the class in the Class Description Framework 35 which describes function arguments, VArgData, has methods to W096/08765 ~ 9 ~ PcT/CA9Snw513 return the name, the type, and the usage codes for the argument it describes. The class which refers too instances, VInstanceData, has methods get and set its value (i.e. the actual instance). The class which describes 5 exceptions is described below in the section on error and exception handling.
The above information is typically constructed by the OSA as NameSpaces are enumerated, however, it may be constructed directly by the user of the system. If the OSA
10 doesn't override any capabilities, as it enumerates its contents, it would typically use subclasses of each of the above classes which, in addition to having methods to retrieve information, have corresponding methods to set the information. Thus, as the OSA determined the contents of the object system, it would construct the necessary instances of the above classes, and call their methods to "connect" them. For example, it would construct the subclass of VClassData which supported these methods, then construct VPropData corresponding to the class' properties, then call a method to set the list of properties in the (subclass of) VClassData. Fig. 4 shows the results of an OSA constructing the description of a DSOM class 11 with one method 12, and one property 13. The method takes one argument 14 and 15, a short, and returns a long 16. The 25 property 13 is of type short 17, has a function to set its value 18 that takes a short argument 19 and 20, and returns a void 21. The property also has a function to get its value 22 that returns a short 23. It will be apparent to those skilled in the art, that the information need not be 30 organized in a tree as shown in Fig. 4.

3) The Type Description Framework: a type management framework to describe both semantic and language types.
Analogous to the Class Description Framework is the Type Description Framework to describe types, including both WO ~/0~65 2 ~ Q n ~ ~ ~ PCTICAg5/~S13 semantic and language types. The Type Description Framework provides a base class for describing types called VTypeData, as well as a subclass of VTypeData called VcrFundamental for representing fundamental types such as integer, float, 5 double, byte, unsigned long, etc. In addition, complex types such as structures (VcrStruct), unions (VcrUnion), pointers (VcrPointer) and function pointers (VcrFunctionPointer), object references (VcrObjectRef), sequences (VcrSequence) including arrays (VcrArray) and strings (VcrString), enums (VcrEnum) and the like can be described using these subclasses of VTypeData. Types can also be nested to create arbitrarily complex types. Fig. 5 Shows the description of a type which is a pointer 24 to a structure 25 containing two items 26 and 27. The first item is a short 28, while the second item is a long 29.

4) The Forwarding Engine Framework: how do these descriptions make it possible to forward manipulations of the proxy object to the real foreign object?
The above elements, class and type descriptions, are combined to fully describe a class. Two key aspect of the method are that elements are tagged as to whether they are semantically meaningful or not, and both semantic and non-semantic information are contained in the description. As a result, the description method is capable of fully describing the fundamental calling mechanism, as well as the language calling convention. For example, Fig. 6a shows a declaration for a simple method call following a CORBA
calling convention. The method 35 takes four arguments: the object 30, the Environment pointer 31 (a characteristic of 30 all CORBA method calls, the Environment pointer is most commonly used as the mechanism to return errors), as well as - arguments entitled X 32, and Y 33. The method returns void 34. Fig. 6b shows the corresponding description of this - method.

W096~876s PCT/CA9S1~513 ~ - 23 -Fig. 7a shows the same method in a different object system which uses a different calling convention. In this declaration, a Dynamic Invocation Interface (DII) 41 is used to call the method. The first argument 36, is the object.
The second argument is an identifier for the method 37.
Next is a count of the number of arguments 38. Finally, the arguments are packed into an array 39. The DII returns an error pointer 40. Fig. 7b shows the corresponding description of this call. Notice that in both cases, only the object, X, and Y are tagged as being semantically m~n; ngful (SM). The other described aspects are merely artifacts of how to make the method call.
In summary, to forward method calls from one object system to another, the forwarding engine walks down the 15 description of the method call that was made, and pulls all semantically me~n;ngful information from the calling stack.
It then walks down the description of the method call it is about to make, and puts all the described information on the "call stack" (each computer system processor has particular rules about where to place arguments prior to making a function call, such place generically referred to as the "call stack") , transferring the semantically meaningful information to the correct position (and converting types if necessary.) It then calls the correct function to actually invoke the method. Once the method has returned, it likewise transfers the results back to the original method call stack.
Shown in Fig. 7c are the step5 that might take place if an object implemented in the object system of Fig. 7, 30 hereafter referred to as the foreign object system, was being used by software written in the object system of Fig.
6, hereafter referred to as the native object system, when the method 35 of Fig. 6 was called.
First, based on the way the OSA constructed the proxy, 2 2 ~
Wos6~76s PCT/CA~/OOS13 the OSA receives the flow of control 701 from the software which manipulated the proxy. Next, based on the layout of the proxy it has constructed, the OSA of the native object system retrieves the real object, as well as the

5 VFunctionDatas for both the real object and the proxy object 702. These are passed to the Forwarding Engine Framework.
The layout of a typical proxy object is shown in Fig. 10 and described in section 7) below. the layout of The first major step the Forwarding Engine Framework 10 performs is to traverse the VFunctionData of the proxy, using it to retrieve all semantically meaningful information from the just-occurred method call 703. It asks the for its list of arguments (i.e. the list of VcrArgument). For each argument determines if the argument is semantically 15 me~n;ngful. If the argument itself is not semantically meaningful, yet the argument is a complex type, the argument may still within itself contain semantically meAn;ngful information. Thus, the Engine must traverse the contents of the argument recursively to ensure that no semantically 20 meaningful information is within it.
Information which is not semantically meAn;ngful is discarded, while semantically meAn;ngful information is stored. In this example, the first argument 30 is the object upon which the method was called. It is semantically 25 meAningful, therefore it is stored (although for optimization it need not be, since this identifier to the proxy object has already been retrieved by the native OSA).
The next argument 31 isn~t semantically meAn;ngful, so it is ignored. The third and fourth arguments, 32 and 33 respectively, are semantically meaningful, and so are retrieved and stored. See, for example, the Intel486 Microprocessor Family Programmer's Reference Manual 1992, hereby and hereinafter incorporated by reference, for an in - depth explanation of how to retrieve information from a function call made on the Intel 486 microprocessor.

W096/08765 ~ PCT/CAgS/~S13 Having retrieved all semantically me~ningful information from the original method call, the next major step taken by the Forwarding Engine is to begin constructing the method call for the real object by placing the appropriate arguments on the ~call stack" 704. In this example, the Forwarding Engine would traverse the VFunctionData shown in Fig. 7 representing how to call the foreign object's (i.e.
the real object's) method, retrieving the list of arguments.
The first argument 36 is semantically me~ningful and 10 must be placed on the call stack. The Forwarding Engine traverses the list of information retrieved from the original method call to find the matching information. In this case, the object. The object from the original call must be converted to the type required by the foreign call and placed on the stack. The Forwarding Engine contains an optimization which ascertains if the object required is the real object (which it is in this case) and so places the real object on the call stack. The second argument 37 is a string constant, "MethodName" (i.e. the name of the real 20 method) which the Forwarding Engine places on the call stack. Llkewise, the third argument 38 is the constant short whose value is 2, so 2 is placed on the call stack.
The fourth argument, 39 is a complex type, so the Forwarding Engine traverses its elements. The Forwarding Engine creates an array capable of containing two long integers. Then, it matches the first entry with the information retrieved from the original call, and so places X in the first position (as a long integer, no type conversion required). It performs the same for the second argument, Y. Once this is completed, it places the array on the call stack.
The third major step performed by the Forwarding Engine Framework is to call the actual method 705. The Forwarding Engine asks the VFunctionData 41 for the address of the W096/0~65 PCT/CAg5/~513 function to call. In this example, it returns the address of the DII function. The Forwarding Engine then dereferences the pointer to actually call the function.
The next step performed by the Forwarding Engine is to 5 handle the return values 706. The Forwarding Engine retrieves it from the call stack. The VFunctionData of the original method call is asked for its return type. The original method call returns void, so no information needs to be placed on the "return stack" (the term "return stackl' refers generically to the computer processor-specific location or locations where the results of a function call are placed).
The final step before returning from the original method call is to handle errors and exceptions. In this example, the foreign method returns a pointer to error information 707. The original traversal of the VFunctionData identified the environment pointer as containing error information (the environment pointer is the native object system's standard mechanism to transfer error information). The Error and Exception Handling Framework is delegated the task of determining if an exception occurred, and converting the information from the form provided by the method call on the real object in the foreign object system to the form appropriate for the native object system. In this example, the necessary conversion takes place, control is returned to the forwarding engine, and ultimately to the process which originally called method 35.
Note that the series of steps taken by the Forwarding Engine can be automatically generated as source code and compiled for performance, if desired. Likewise, note that the above description was given in the context of method calls, however it applies to all manipulations.
Furthermore, the object being manipulated need not be from an object system, as long as the requisite description is 35 provided. For example, this enables straight C language W096/08765 ~ g ~ PCT/CA95/00513 software to appear to be implemented in any object system.
OSAs have a choice as to whether they have the system's Forwarding Engine Framework code handle forwarding of methods automatically, or whether they subclass the framework to provide a custom forwarding scheme. In some cases, the OSA can look at the description of the method call that is about to be made (i.e. not the one just made that has to be forwarded), and determine what semantic information must be removed from the call stack. By virtue of the fact that the OSA corresponds to the object system in which the call was just made, the OSA writer can code into the OSA how to remove information from the call stack - the OSA need not walk down a general description of its own method.
Likewise, the OSA that constructed the VFunctionData for the real method (i.e. the method in the foreign object system) can construct it so as utilize whatever means it finds necessary to accomplish the real call. For example, the OSA can construct the VFunctionData so as to "call back"
into the OSA for further custom processing.
The above descriptions of classes aren't specific to any particular object system. They can be created by any object system to describe their classes, and they can be traversed and "executed" by any OSA to forward manipulations of objects by any object system to any other object system.
AS a result, the method to forward object manipulations isn~t an N2-N approach.
A similar method is used when objects are queried for a description of themselves. The description of the native object is traversed, as triggered by the proxy, either by the Forwarding Engine or by the OSA, and the semantic information converted to the format required by the object system making the request. The formatting of such information is one of the responsibilities of an OSA.
AS mentioned, types, including semantic types such as W09610876s PCT/CA95/OOS13 strings and variables containing any type, as well as language types must often be converted between object systems. The system provides an object oriented type system, the Type Description Framework, capable of converting semantic and language types between any two object systems in a non-~-N fashion. The Forwarding Engine pulls information off the calling stack by utilizing the type information in the description of the method just called. When walking the description of the method about to 10 be called, it likewise knows the type expected. Knowing both the original type, and the expected type, the Type Description Framework performs a conversion.
In the specific embodiment, two mechanisms are provided for type conversion: object oriented type casting, and 15 neutral type representation. In object oriented type casting, the Type Description Framework can convert among types that are all subclasses of the same type. This is accomplished by the superclass, VTypeData, providing a set of methods which each of the subclasses implements. These 20 methods return the information necessary to construct an instance. This information is sufficient to create any of the subclass types. Thus, to convert, these methods are called on the instance of the type just pulled off the stack. The results provide the information necessary to create an instance of the type which is about to be put on the stack.
In neutral type representation, types know how to convert themselves to one or more neutral types, as well as how to convert from neutral types to themselves. For example, a string type such as a COM Bstr, as a sublcass of string, would have methods to convert itself to either an ASCII string, or a Unicode string, as well as to convert from them to Bstr. Thus, to convert from any string type to any other, the first type converts itself to ASCII or 35 Unicode, and the second type converts from that to itself.

W096/08765 ~ PCT/CA95/OOS13 Note that the types can agree on which conversion is most efficient, and that conversion only takes place if necessary. Furthermore, those skilled in the art will recognize that the above doesn't preclude the addition of a direct type conversion mechanism between particular object systems (and types) where type conversion optimization is desired.
The Type Description Framework is also used to trigger automatic proxy construction. That is, when an object type is passed, the object needs to be "converted" to an object of the to-be-called object system. Thus a proxy needs to be constructed. The detailed steps involved in proxy construction are described in sections 6) and 7).
S) The Error and Exception Handling Framework: a framework to handle errors and exceptions.
The Error and Exception Handling Framework relies heavily on the type conversion system. As a part of every VFunctionData, a VExceptionData is created. When any exception occurs, the type conversion system converts the exception from the type in one object system to the corresponding type in another. In addition, the type conversion mechanism via the methods in VExceptionData, is responsible for triggering the exception handling system of the foreign object system.

6) The Lifecycle Management Framework: a framework to create, copy, destroy, and (manage the lifecycle of objects) and

7) The Object Exporting Framework: a framework to export object definitions.
Although object lifecycles differ among object systems, the lifecycle of an object in a typical object system is shown in Fig. 8. The process begins when a user asks to create an instance of an object 42. The object system first determines if the factory to create the object is available W096/08765 ~ PCT/CA95/00513 43. If the factory isn't available, the object system attempts to start the server 44, as specified in the call to create the object. The object system starts the server application (or loads the appropriate dynamically linked library) and transfers execution to it 45. The server performs initialization and creates factories for all the classes it supports 46. Then, the server registers its factories with the object system, in a process sometimes referred to as "exposing its factories" 47. When the 10 process is completed, the server returns control to the object system 48. The object system then calls a method of the appropriate factory to create an instance of the desired class 49. The factory creates an instance of the object 50, and finally, the instance is returned to the user 51. As the object is utilized, additional references to it may be created 52. The object may be destroyed by any party that has a reference to it 53. Each time a reference to the object is used to destroy it, the server determines if any object cleanup is necessary 54 (e.g. should memory the object is using be de-allocated). Typically, this occurs when the last reference is destroyed.
The system provides interoperability transparently. As a result, it must appear to the object system as a standard object server that follows the standard lifecycle protocols that any server designed specifically for the object system would. The system, or more particularly, the OSA for the object system in which the request takes place, is therefore responsible for items 3, including items 5 and 6, item 8.5, and ensuring that during 10 and 12, all utilization/manipulation of the object is forwarded properly, and transparently to the real object. During 8.5, however, the OSA works with another OSA - the OSA of the object system that the real object is created in, to create a proxy for the real object.

W O 96/08765 ~ ~ ~ O Q ~ ~ PC~r/CA9S/OOS13 The system provides a framework to perform the above steps - the Object Exporting Framework. Any application/server that contains the system may be 44. As shown in Fig. 9, in performing step 46, the application initializes itself 55, then initializes the system 56. For each class from another object system the application/server wishes to make available in this object system, the ExposeFactory method is called 57 in the OSA of requesting object system. The list of such classes may be hard-coded in the application/server, determined from a persistent store or file, or dynamically determined. The Expose Factory method is called with the VClassData of the class to be exposed, and returns a real factory object from the native object system. It constructs a new factory if required 58, or returns a previously created factory 59.
The method also registers the factory with the native object system 60.
Another aspect of exposing classes is registering them in the native object systems "repository." This may involve generating an interface description in a "language"
appropriate to the foreign object system (such as Interface Definition Language or IDL in CORBA systems, a Type Library in COM, or C++ header files). It may also require that the OSA use an API to register the class with the object system's repository.
When the object system calls the method of the factory to create an object instance, it is the job of the factory to create a real instance in the ~oreign object system, then to create a proxy to be returned to the native object system (i.e. the object system which the factory was designed for.) When the OSA constructs the factory, it builds the VClassData for the object in its object system. This VClassData, and the VClassData for the real object (which the OSA was provided in the ExposeFactory method call) are stored with the factory object. When the factory object~s W096/08765 ~ PCT/CA~ 13 method to create the object is called by the object system, the factory object uses the Forwarding Engine to forward the creation call from its object system (using the VClassData it created), to the native object system. When the real 5 object is returned, the factory object constructs a proxy object by calling the AcquireProxy method in the OSA for the foreign object system (more precisely, in the subclass of the Object Exporting Framework provided in the OSA).
The AcquireProxy method is passed the VClassData of the real object, as well as an instance of the object. It constructs a proxy object in the native object system, associating with that object a pointer to all the information required by its OSA. Although the layout of a proxy object is up to the OSA, a typical proxy object is shown in Fig. lO. The proxy object 61 consists of a pointer to its method table 62 (referred to as a vtable in C++), as well as a pointer to a metadata object 63. The metadata object consists of a pointer to the method table 64, a pointer to the VClassData of the native object 65, the 20 native object identifier 66, and a pointer to the VClassData of the proxy object 67, as well as path shortening information 68.
The first time an instance of the class is created in the native object system, the AcquireProxy method of an 25 object system typically has to create a method table. It will be understood by those skilled in the art how to dynamically create a method table, and how to associate with each method, sufficient information for the OSA to retrieve which method was called. When the method is called by the 30 object system via the method table, the following steps are typically performed: First, the VFunctionData for the - method of the proxy object just called is retrieved. Next, from the metadata of the proxy object, the VClassData of the - native object is retrieved, and in turn, the VFunctionData w096/08765 ~n~s~ PCT/cAssloosl3 for the corresponding method of the native object is retrieved. These are passed to the forwarding engine for forwarding of the method call.
Construction of a proxy object can be triggered by the 5 user, as in ~2, or by the type conversion system. When triggered by type conversion, only AcquireProxy need be called. .
When the AcquireProxy method is called, prior to creating a new proxy object, it must check if a proxy object for the native object already exists in this object system.
Utilizing a capabilities provided by the system, the method checks its cache of objects. If a proxy already exists it is returned, other wise the system checks if path shortening is required. When multiple systems are working cooperatively to provide object system interoperability, it may be that the object for which a proxy is to be constructed is itself a proxy object. Path shortening refers to the act of not creating a proxy for the proxy, but rather 'Ishortening the path of objects" and creating a proxy for the real object. Those skilled in the art will appreciate that there are numerous path shortening algorithms described in the literature, for example "SSP
Chains: Robust, Distributed References Supporting Acyclic Garbage Collection, Shapiro, Dickman, and PlainFosse, Symposium on Principles of Distributed Computing, August 1992", which is hereby incorporated herein by reference.

8) The Mixin Support Framework: a framework to add extra information to the description of any object class, enabling the support in all object systems of features found only in one object system.
Often one object system provides features which aren't available in another object system. In addition, object systems often expect their object to provide certain features. The system provides a general mechanism to handle such interoperability issues called mixins. Mixins are Wo ~65 PCTICAgS/~S13 simply objects which may be associated with any other object in the system to extend the functionality the object is capable of providing. A mixin can provide a method which the native object doesn't provide, or override any or all of the native object's methods. As all Frameworks are subclassed from the Mixin Support Framework, mixin objects may be added to any instance of any class provided from the system.
When the forwarding engine walks down the VClassData to retrieve the VFunctionData for the native object's method, it first determines if there is a mixin object associated with the object that provides the method. If so, it calls the Mixin's method instead of the native object's method (if the method even exists for the native object.) The methods of mixin objects can also be triggered to execute prior to, or after any native method call to augment the native object's capabilities. Mixin objects may be associated with the objects known to the system at the class level, or at the instance level. In addition, they are inherited as subclasses of objects are enumerated. Through the Mixin Support Mechanism, a native object need not be aware that its capabilities have been augmented.

9) The OSA Registry Framework: a framework to load, unload, and manage Object System Adapters.
As previously described, Object System Adapters are libraries which package together extensions to the system's default implementations of the above frameworks. An OSA
packages everything necessary to fully support bi-directional interoperability among the object system to 30 which it corresponds, and all other object systems with OSAs. The system can dynamically load and unload OSAs using a framework entitled the OSA Registry Framework. The OSA
Registry Framework provides the methods to load and unload AdapterNamespaces, and provides the remainder of the system 35 with an object system independent way to determine which wo 96~65 ~ a ~ ~ PCT/CA95/~S13 object systems are supported. OSAs can be loaded and unloaded while the system is executing, dynamically extending the range of object systems supported.
Futher Embodiments of the Present Invention The invention in a range of other embodiments. In another embodiment, for example, there are provided (A) a system and method to enable the creation of a "universal object", i.e. a single object that appears to be implemented in a plurality of object systems simultaneously, and that can dynamically change which object systems it supports. Such a system enables the creation of "universal objects" in individual, application, and server ~ configurations. Further, such objects may be based upon interpreted or compiled language technology.
In addition to enabling heterogeneous object systems to interoperate, such a system, when used in a slightly modified configuration, enables objects to appear to be implemented in a number of object systems simultaneously.
Fig. 11 shows an example of the system being used in such a configuration. In the figure, an individual COM object 69, appears as both a DSOM object 70 in the DSOM-based application 71, as well as an ORBIX object 72 in the ORBIX-based application 73.
There are two configurations in which typical object systems enable their objects to be used: "in process"; and "out of process". See, for example, the OLE 2.0 Programmers Reference, and IBM SOMobjects Developer Toolkit Programmers Reference Manual. When objects are used ~in process~, they are used as a "dynamic link library" (DLL) - often referred to as a shared library - and execute in the same process space as the software using them. When objects are used "out of process", they execute in the process space of the separate application or server they are within, not within the process space of the software using them.
Although Fig 11 shows all objects executing in separate Wo ~/0876s ~ pcTlcAs5l~sl3 processes, it will be obvious to those skilled in the art, that for object systems which support in both in process and out of process objects, the system may be used in either configuration. That is, when the system is used "in 5 process'~ by an application, the system, including the various frameworks, and the OSA for the object system being used by the application, as well as the proxy objects being used by the application, execute as a DLL in the process space of the application. Note that while the proxies are "in process", the native objects (i.e. the real objects which correspond to the proxies) need not be. They may be in process or in a separate process, as determined by the way they were created in their native object system.
Conversely, while the application using the objects may create them "out of process", even though the system is executing in a separate process, it may create the native object "in process" for efficiency. In this case, in process means the objects are created in the system's process, and not in the process of the application using the 20 objects.
Fig. 12a shows an example of the system enabling a universal object in an individual configuration, while Fig.
12b, and 12c show application and server configurations respectively. In Fig. 12a, 74 is a COM DLL containing three 25 objects. Object 75, is an individual object (i.e. an object not within an application or server) that, through the system, may appear to be from multiple object systems simultaneously. Additional object systems can be supported simply by adding corresponding OSAs. It will be obvious to those skilled in the art that the DLL, 75, may contain one or more individual objects.
Fig. 12b shows an example of the system being used in an application configuration. The system is linked into the application, 76, which includes application objects. In this example, the application has described its objects W096/08765 pcTlcAs5l~5l3 directly to the system (as would have an OSA), so no OSA is required. The application's objects, through the system, may appear to be from multiple object systems simultaneously. Alternatively, by providing the appropriate 5 OSAs, the same objects may appear to be implemented using different object systems on different platforms. It will be obvious to those skilled in the art that, had the application utilized an object system, an OSA could have been utilized.
Fig. 12c shows an example of the system being used in a server configuration. The characteristic of a server configuration is that the object server, i.e. the process or processes containing objects being used, are in a separate process from the application which is using those objects.
In Fig. 12c, the objects, 77, in the server, 78, through he system, may appear to be from multiple object systems simultaneously.
In Fig. 11 through 12c, the objects have been shown as compiled objects, however, they need not be. They may be objects written in an interpreted language, whether fully interpreted, or executed through an intermediate representation. All that is required is the interpreter provide some fundamental mechanism by which its objects may be accessed and manipulated, and that either an OSA be 25 written, or the interpreter describe its objects directly to the system. The utility provided by such an approach is that objects may be written in the language of the interpreter, and those objects may, through the system, appear to be from any object system with a corresponding 30 OSA, thus taking advantage of the rapid development characteristics of an interpretive language environment.
In a futher embodiment there are provided (B) an apparatus - either library-based or interactive - to enable the construction of object classes from one or more object systems, including the aforementioned "universal objectll, W096/0~65 PCT/CA95/~513 where such system in the creation of said object classes, may subclass from, incorporate, or embed instances of objects from a plurality of object systems;
Heretofore, software, either library-based or interactive, which enabled the construction of applications from objects, and/or which enabled the construction of objects have required such objects to follow the single object model supported by the tool. For example, see Microsoft Visual Basic V3.0 Professional Features Book 1,

10 Control Development Guide, 1993. In some cases, dynamic converters have been developed to enable the use of objects from one object system within other an object system, with all the consequent limitations, however, they have not enabled the construction of foreign objects. For example, see Borland C++ V4.0 User's Guide, 1993.
For the apparatus, the system is used in the application configuration, where the application software is that code, hereafter referred to as construction software, that is well known to those skilled in the art, for construction of 20 applications from objects, or for the construction of object classes. To construct applications or object classes, the construction software loads object classes from any object system with an OSA ~in addition to any which follow the construction software's own internal object model, if any.) 25 The construction software manipulates the foreign object classes using the system frameworks directly, or alternatively, using the mechanisms from its object model.
As a result of the uniform means to manipulate objects from a plurality of object systems provided by the system, the apparatus is enabled.
In another embodiment, there are provided (C) a system and method to enable object classes and objects to be relocated among applications and servers in one or more object systems while the applications and servers are executing, and without disruption of software utilizing said WO 96/08 765 ~ PCT/CA9S/OOS13 object classes and objects, even if it too is executing.
When used with ~in process'~ objects, or when used with an interpretive language environment in individual, application, or server configurations, the relocation of object classes and objects among applications and servers in one or more object systems is enabled. To move an object class, first, a version of the class must be available in the new location/object system. This is accomplished by:
moving the native object definition. In the case of in-process objects, the DLL they are within must be copied or moved by other means. In the case of an interpretive environment, the source or the intermediate representation must be copied or moved by other means to the new location, and loaded into the appropriate application or server using the system to expose the class in the new location and/or object system updating the description of the object class in the system, including its VClassData and other descriptive elements, to reflect its new location and potentially new object system.
If instances of the class already exist and are not to be moved (i.e. only new instances are to be in the new location/object system), the version number of the class must be incremented.
As new instances are created and manipulated, they will be created and manipulated utilizing the new description, thus properly for their new location and potentially new object system. The method applies both to foreign objects, as well as to native objects as long as, for native objects, the system is utilized to perform the creation and manipulation of objects.
Object instances are moved using a similar mechanism.
All existing proxies for the instance (i.e. each proxy for each object system and user) must simply have their software description of the native object updated to reflect the new location and/or object system of the instance.
It will be appreciated that, although specific embodiments of the invention have been described herein for 5 purposes of illustration, various modifications may be made without departing from the spirit and scope of the invention. Accordingly, the scope of the following invention is limited only by the following claims and their equivalents.

9 ~I PCT/CA9SIOOS13 Visual Edge So~ware Ltd.

Class Registry Functional Specification SUBSTmJTE SHEEr (RULE 26~

WO 96/0876S ? ~ Q ~ ~ ~ PCT/CA9S/OOS13 --~2--Overvicw . . . ., ........... , ......................................... ~4 Class IT' ~ 45 HowThis~e''-~t' IsOrgani~d 49 Types and r ' ~ . ,, ..... , ...... . , . . . , ..... 51 Suppon Classes . .......................... ............. .. , .... 56 Class VaHelp 56 Class VcrC ~-r - ~
Class var T."f 58 B. se Classes ..... ......................................................................................................... 62 Class VaBase 62 Class VcrToplevel 65 Exposed Classes ... , .... . ................. ... ..................................... 68 Class VcrArgument 68 Class VF~ q 68 CLss VPropData 71 - ClassVl ~ q 72 Class vr ~ ~.q Class V~'~q~ q 7~T
ClassV~ S, 81 Class Wi ...... 1~ Sr 88 Class V~lqccR~
Implementation Classes ..... . ........ ., ., ............ 101 Class VaC~. ' 101 Class VcrCo~v~, 102 Class VcrC~CI 103 ~ Class VaSimple~ 110 Class V~dapter 111 Class VaSimpleView 111 Class VaFlatView 112 Type~' _ C . . , .113 F~ ~ ' i Types 113 Class V~ta 114 Class VaFunda nental 118 Class VaAlias 119 Class V.,~F~ ' 119 Class VcrO~ f 120 Class V.,.F~ ' T~ll 120 Class VaSI,, "1 121 Class VaStruct 121 Class VcT~ It~n 122 Class VcrEnum 123 Class VaS~ . :f l2'T
Class VaArra~ 126 SUBSTmlTE SHEET (RULE 26) wo 96,08765 ~ 2 n o o 9 ~I PCT/CAgS/ooSI3 Class VcrsL., ~- . 126 Class VcrString 127 Class VcrAny 127 Class VcrU~ Tl~.n 128 Class VaUnion 129 Class VaStruaUnion 130 Class VcrOpaque 130 Class VT~ L 132 Mi~ns..... . . .................................................................... .. 137 Class Vcr~ f 137 Class V~ ~,. 137 SUBSTITUTE SHEEr (RULE 26) WO 96/08765 ~ PCT/CA95/OOS13 Overview Trans~ t Object System Support ~o compete in today's onerging global economv one m~t . n _ Business Week.
S~~r i _ various object svstems in a product that runs on multiple platfonns has I "y been 1~' ' The same object systans are not al~ avs available on all platforms. The object model of choice on one platform is not lil~ely to be the most common on anotha. Given that this diversity currently exists and will likely continue for the f~ ' ' future, the ~, ' developer is faced with ~u, . i _ multiple oyects systans.
S ~r i' _ multiple object models _' its own problems. It is usually .' ' and time _ to write code for object systems such as OLE and DSOM. The i ._ required to learn the of each individual objects system is , ' In addition, coding to an object model can involve extensive ~ e of the original code. The fhal rwrench in the ~vorks" is that if an 1~ r~' " is coded to one object model, this generallv precludes coding to another at the same time.
Recoding to vet another object svstem ~vill again require a _ ' "There's got to be a better waV ... " - RonCo Industries PLC.
The Visual Edge elass registry -' these problems and :' '1. reduces the i....
d- . ~ . must malce to support multiple object models. The class registry abstracts each objecls svstem behind a c~unon API for d ' _ classes, methods, propcrties, and data types. The API is designed to easily intaface to your existing class hierarchv. Once your class hidv has been described to the class registrv, support for new object systems comes without anv - ' ' required. Support for individual object systans csn even be installed and removed at runtime.
The class registry interfaces to an object svstem through ~m object svslem adapter. The object system adapter is r ~~ ~ for managing the de~ails of the object systan tha~ it supports. The details of this object system nev~ necd to be exposed beyond the adapter. Once an object system adapter is installed in the class registry, any chss known to that object systan can be ~ h ~ to the class registry as needed and vice versa. The object s~ntem adapta handles all the details of exposing any object inslance described in the class registry to the object system that the adapter . The adapta also manages the detJils of _ sny object inst~mce from its object systnn baclc into the chss registry.
"B#t wait ... ~hcre's morc ... " - Ginsu Knives Inc.
The same ' ' ~ which allo~vs tbe chss registry user to t~ . ' - objects from sny object system also allo~vs it to act as an objeet system ~bridge". The class registry can provide a pathway from one object syslem to another. This would allo~v, for instance, sn OLE ~ ~r~' " t~
control DSClM objects and vice versa using the chus registry u a bridge. Or u another e~mple, this could ~llow ~n OLE ~ _..' to co~ol an OLE ~ object o~ a di~crcnt machine--u~ing DSOM to msnage the :' ' ' . _ snd the class registry on both ends u the OLE ~ DSOM bridgc ~he object systems supp~tod by the chss registry through object system sdsp~rs ~Ire wt limited to the ' def~nition of ~object system~. An object atapter could be build to interface a tatabue to the clus registry. This tatabue coult then be sble to be scc~ed easily from sny ~dard object sys~ The class re~y can also be used to intcr~ce standard object systems to ~"~ r ' ' ~ object systans--with the addition of an objcct sys~em sdspter for the 1~ ~r ' y object systan. Ihis would provide _ ' leverage for users of the ~ objcct s~em, since it would alable thcm to continue using their objcct system while accessing objects in otha object svstcms st the same time.

SUBSrlrUTE SHEEr (RUI E 263 ~nnos ~

The class registry is able to make all tbe installcd objea systems appear as a simple unified _".".
However, different users of object svstans have different needs. Some will want a llat name space for all chsses and types while othas will wDnt a strict I _' ' grouping of class and type names. Others may choose to define their own hierarchy of name groupings which more closely relates to their current tasks.
The class registry supports this through the use of views. A view defines a name space hierarchy which is ~ ' . ' of the actual hierarchy defined by the object svstan adapters. Multiple different views can be created for an adapta based hierarchy so tbat a user can or~ize his classes in different ways for different tasks. Views can even be ~ ' without affecting the code which ..f_. classes and types inside them. Finally, d~ ,lv~ can subclass views to provide a persistent name space hierarchy to their users.
"U~haJ toes this metm ~o me? n _ KTel ' ' ' ~ Ltd.
The class registry provides the base ' ' t~ to interface to any object svstem. This allows d ..,lq~:, the freedom to focus their resources ~ their specific strengths. The class registr~'s single, portable API
results in decreased J~..', and costs over the life cycle of an . ,1; as new object systans appear and others become obsolete. This translates into ~i, ' savings in overall ..
and time to market.
Class Hiel~c~-y The class registry serves much the same pulpose as an IDL or C~ header file of class, function, and tvpe ~' ' That is, it ~r- ' class and type I .' ~ through C~ classes. Classes and ty~es csn be entered into the class registry from static, dynanuc, and database like sources. Static sources of class and type d ' are typicallv class registry entries coded by hand and stored in a ~code adapter~ I)ynamic swrces, such as OLE and DSOM, provide class d ' to the chss registry through their native ~ r " ' Databssc sources, such as type libraries, provide a ' to demand load classes into the class registry.
As well as defining class I .- the chss registry provides a flexible dynamic wav to advertise class interfaces to hnguage i . builders, object browsers and property editors. The classes in a class registry can be b~wsed as a whok. or they csn be queried by name, version number, object system adapter, etc. The user of the class registry (an . _t." builder, etc.) does not need to be concerned with the swrce of the chss. The class raay come from any object sys~n inslalled in the chss registry.
The chss registry does not hide objects deflned in foragn ob3ect sys~ns under layers of overhead. The clas~ registry . ~ its class instsnces by actual pointers to the inslsnces; no _ .. or casting is required This allows the chss registry to access objects as fast as their native object svstem can access the~
A clsss ~' p' in the chss registry consists of the class name, its base class (or classes), and lisls of its methods, ~ - ~ - properties, nested types, e r ~ ~ , and named cooslants or instances.
Each method and property consists of so ne ~ (the name, data type, and list of I ~ with Sbeir types), together with hoal~s for actually acce~g the member on live objects. Each method ~d~ 'r ' includes a function pointer that software using the class registry csn csll to invoke a method.
Fw h property ~ can include two acccs~or mdh-od d p~ one to gd the value and anotha to set h P~ or ~ properties may omit one of the accessor methods.
C-csllable furctions are used for genedity. Most compiled hnguages support C for extanal function cslls.
It wwld be . to gi~e access to C~ methods amd data men~ers directly, but ~. b - imposed by the Isnguage make Uhis . ' for classes developed ', ' '~, of the class registry. For situations where the C~ mdhod .' is 1~ ~ '~ (such as platforms using the MiaosoR
Object Mappingl diroct .~,. - of ~rirtual methods is supported For the same reasons, data maobas are ,~.~.. ' by a psir of accessor functions ratba than a direct offset or memba pointa.

SUBSTITUTE SHEEr (RULE 26~

--4~--llle followin~ dia~ram shown the class hierarchv of the class re~istrv. The classes with I ,' li,' ' borders are desiFned to be able to be ~ ' ' ' bv us~s of the class r~y.
VaSase 4 VaTopkve I ~ V~
4 VaType I ~ VCbssData ¦ ~ W~ ~ S~ ¦
VcrPoint~ ~ 4 VcrCo ~ ¦ 4 vc s . ~.. I

~ VaObjectRd ~ VFu n--~ ¦ 4 v~ v ~rL. ~ 4 Vac~rL
Vc 8~ ¦ VPropData var~ 4 VcrCc ~ ¦ ¦ VcrC ~ , . ¦
VaAlias ' ~ V; ~ VaHelp --¦ Vc Fu~r I --¦ VC- , ~~~ I ¦ VaDablRd Y~ VA, ~ ~ l v~ 4v~s . . 1 I v 4 v c ¦ ¦ VT~, VaString I VcrS~ucU~ I
VaAny 4 VaUnionllem ¦
'¦ VaUnion ¦ I
4 v~ I I V~- I
VaOP~
The class rqsislry provides an extensive instance hierarchy to define cls~ses. To facilitate the ~ ~ ~ e of this hielarchy the following figure 1~. a sample ins~mce hiemrchy. This is intended ouly to give an exan~le of the instance layout of the dass regi~y and its ~ , This figure is not int~ded to be c~mpletc but to simply give an overview of the instance layouL The solid anows rep~t direct pointcrs to objects. This hierarchv repr~ents a class regis~ay with tw~ object svstem adapters installed. Thc class registry contains one class w hich defines one method and one property.

SUBS~I~UTE SHEET (RULE 26~

WO 96/08765 ~ PCT/CA9S/OOS13 vc ~
L . v~ ~ ~; I 4 T v~ P ~ ~ F) J w,. ~, 4 DSOM vcl~ssLht~ (cta~s ~ith or~ n~thod ~nd on~ p-op~y --¦ vr. ~ ( M thod d~d # bng : t. ~tnJet ~.. ) ~
4v~ r. ~ ' 1 4 ~ ~- I 4 ~ ~.
r~ 4 vA~t-- !
VP~xDat-(P~pn~d~ dh~t) I4 v~stn~t vr. ' (S~t) I ~
4v~ ~-rl 4 ~ v~ !
J vr~ t) ¦ I ~¦v~
.r. .
Staac Entries The class registry supports the creation of statically defined classes wit}t methods and prope~ies, types, func~tons, ~ and nsmed ~s. Static instances are defined by _ ~nstances of the c~s VcrCode~Cl~q~, VcrCodedFunction, VcrCodedProp, VInqtanceData, and VExceptionData. Ibese classes pronde Aprs to sn install methods and p~paties in chsses, tD add , etc. Cbsses are defined by creating a VCodeclC~ object. Methods and p~ties (VCodedFunction and VCodedProp instances) are added ~o the cbss u$rg its methods AddMethod and AddProperty.
Methods are defined with a set of ~ ~ (instances of VcrArgument) which are added to the method usi~gAddArgument. A C callable function must be p~rtded when def~g a method Using wrapper functivns for class methDds can malte ' ' ~ objects easi~, especially in scripting sitltations. The wrapper _ need not be the exact lypes used for thc ~ _ ' of the . ' '~' _ class; the w~pper can cvmrert f~n simpl~ types (like 'int.') to specific types such as that are difficult tD express in a l~mguage such as Basic. You can register read-only p~perties by either supplying a N11LI, set func~ivn or by setting the usage flags of the pr~ty tD ~read only~.
T,he type of each C wrapper functivn matches the member function it represents except that it is a file-scope function (or static member) with an instance pointer as its first argument (an explicit "tbis"). Macrvs . an be defined which generate both the wrappers for C~ cbss members and the class registry item c , ' c,ode.

SUBSmUTE SHEET (RULE 26) -Dynan~ic En~aies In addition to desling with static entries the class registry can deal with higllly dynsmic enlries. For exsmple, in ~_ object d.. ', or object svstem bridging, the content of the class registry cau change as the user browses and queries for e~anal classes or as the user adds or modifies their own classes. Whesl the class registry is connected to an object system which is dynarnic, the class registry itxlf is dvnssnic.
D-,. P, ~....i.~ such as language ~ , _t .~ can consult the class registry for all external type and name bislding ' at cosnpile-time, run-tisne, or both. The results of a query at I ~ may indicate sirnply that the Imswer be deferred until runtime. If classes are defiDed statically their d ' can be available at compile tisne. If classes are being imp~rted frosn an object system such as DSOM or OLE, they may be available at compile time, but all their methods and properties may not become available until an instance of the class is accessed. The class may also be relrieved from a database adapter. If the clsss is not found in the local cache. the database adapter may perform a query on the database to find the clas. d The querying intesface of the class registry is defined by the abstract class WiP l ~space.Nsme-binding services are provided through its virtual methods. Client processes will typicallv be . 5, ~i ~ith one VCla~.~Regi~try instance while server processes may have one class re~y instance per clienL
Typically, the class legistries ' by a pro~s msr~e a set of r ' 1- ~ adapters, each able lo query diffesent sources of class and type ' The intd clsss registry data serves as little more than a cache for ' derived from these other sources (such as interface --r " ' )~
The special ._, of each object system adapter can be met bv defsning - ' ' Of the class registry item classes. The regislry item classes define the structure of the class registry and the API for inspecting it. The registry is an abstract API which is always caosulted through the item classes' virtual member functions.
Mixin r~
The class registry defsnes a rnixin ~ ... ' for its own classes. Every item in the clsss regis~y csn be exknded with mixins. Mixins on class registry entries csn provide support for ' ' ~,~ which is available in sosne object systems but ~t supported by all object systems. Mixins c~n also be used to augment tbe ' ' ~ of the class registry beyand its basic ~ . ' For instance, wt dl objec~
systems can support exposing chsses from the class repstry to their oyect syst~L Thus, object systems which support exposure can provide an exposure mixin while thox that do wt support exposure will not provide an p' - of the exposure mixin The mixiD ' allows the chss registsy to befully e ' ' - without any . , ' ~ of bax systezn modules.
Visud Edge will be worlciDg with its psrtners to define standard suites of mixins (anslogous to Appk Event Suites). This incralses ~, . ' . ' ' ~ and helps promote a strong mari~d for add oD teols.
Mi~ns can be psoviW in Imexks~l DLL so that if the mixin is wt quaied tsle DLL does not neod to be lo~d This dso dlows a syslaD to defiDe its OWD "add-vn pachges". The adt-on pacl~ages can be DU's WDiCh contain ~, ' of mixins. If the DU is Dot fo~md, the mixin is not p~vided and the system can cantimle with its de&rlllt bchavior.
The mixiD e ~ ' ' ~ ' arn also provide man~y c .~ savings. Mixins are d~
created when first ~ ' They are anly ; ' if reques~eli SUBSTITUTE SHEEr (RULE 263 wo 96/08765 ~ I PCT/CA9S/OOS13 --4~1--Thc class tcgistry prvidcs the capability to providc 1,,'' ' and rnhYin r .,_ which ate ' ' . ' - of the object svstem in which thcy arc ' .' ' That is, an a.,'' ' defincs a f _ ' of absttact classcs and mixins in its own objoct systc~n. If the 3~' ' is "class registry aware" then third panics may dcvelop thcir ' . ' ' of tbe r , ~ classes or nuxins in thcir own choicc of object system For example, a builder mav dcfine tLuxins fot r ~ ~ cditing of objccts such as fonts and colors. Given this standard mixin definition, a third pany could ' . ' a r ' I' ~ cditor in OLE us ng the stan~hrd mLYin dcfinition evcn though the buildcr may operatc on DSOM objccts. This allows usets to have ftoedom of choice and it allows ,vout a" '' ' to havc grcatcr ' v~dbilit~.
How This Specification Is Or~ni7e-l -Thc ' ' of this r ~ 5 ~; dcfines the classcs and types uscd by thc class re~y.
~ Thc fitst scction dcsctibes the _ ' and typcdc& uscd 1' . _' the class registry.
Thcse atc gencral types ubich are uscd in mote than onc location and for motc than onc purposc. Typedcfs which arc specific to an individual class ate listed with the class itsel~
~ Thc second section defines genelal classes fvt help support, data 1~ .. , and function cdll errt returns. These classes ate used for spccific hclpcr functions such as d~ i,L and hclp support, etrt teponing, and data rcf~ence counting.
~ Thc thitd section outlines the base classes used as the f ' ' fot the class registrv classes.
These classes provide API suppolt fot pctvasive ' ' ' such as usage codes and help ' ' ' on cach element.
~ The foutth section defines the classes which ate exposed to a uset of the class registry. Wbile these clssses are the API to the outside wovtld ~ . ' ' may actuallv be ~ The fiflh section describes the classes which are ' .' ' of the exposed abstr_ct classes. These classes are available fot use by ditect ' -' ot b,v ' ' ' e ~ The sixth section defines the type _ ~ hieratchy fot the class registry. These classes ptov,ide the suppost fot type casting _nd .. , ' be~wn object systems.
~ The last section outlines the cutrently defines _ ~ ' These ~ ' are available as mixms on p. tticulat class tegistry entries which support the f ~ ' ' '~ .
The class legistry uscs the following Visual Edge u~ility classes. These classes are not defincd in this documenL SofLwate using the class tegistJy teqlmcs access to the libtaties which define these classes.
VArray r - typed array.
VAtomDictionary Atomkeycd hash table.
VCla~ Support fot run tune type ' ' ~ ' ~ ~ -W alue r . ' ' uDion over integlal types.
VString r , ~ C string.
VAtomRef String id~ltifiers used for fast hashing and .
VPrimary Base c~ss for mixin supxnt.
VrPri~ary Base class for reference counting and mixin suppo~
VMixin Base class for mixin . ' ~ ~
VrReference Smart pointer tcmplate to an obje.,t u~ich kceps track of reference count of the object. This is needed for proper ~ '-' I' ._d support.

SUBSmUTE SHEE'r (RULE 26~

VrRefLi~t TaDplate of an anav of pointers to objects ~hich kecps track of refaencc counts of the objects. This is needed for prop~ multi-thread support. Note that this is not an anay of VrReference objects.

SUBSTmlTE SHEET (RULE 26~

WO 96/08765 ~ O ~ PCT/CA95/00513 Types and Enumerations Usage Codes The registr,v associates a usage code with mest items. The usage code is of type VTUsageCode and is a of bit flags ~ ' how the item can be used, such as "hidden" for properties thDt r C~:~ can '. ' but should not make accessible diredlv to the user.
UsaEe codes supply ~ ~ and . ' ' details: for example, you do not use separate types to specify call-l, ..f~c - vcrsus call-bv-value ~r~, , a usage bit marks function ~L ' as call-by-refcrence.
The usage bit flags are context-specific, and may carrv diff~ent meanings l'or diffaent classes of item (the same bit ma,v mean one thing for a propert,v and another for a class). The table below ' which usage codes apply to which classes and also which users are most likely to refer to the usage code.
Usa~e Code CF M P E T I 1~ A L B V
kW~ageReadOnly ~ ~ ~
kWsageWriteOnly kWsageDef aultProperty ~ ~
kWsageProtected kw sageThreadsafe kWsageStrict kWsageVarArg kWsageCallerI Owner kWsageByRef kW sageHidden kWsageOptional kWsageHa Def ault kWsageValue kW-~ageOut kWsageInOut kW ageDynamic kWsageDeleteNotify kWsageCannotSubclass kW sageDoNotCache L~Beod C VCla~Data F VFunctionData M VE'unctionData (method) P VPropData E v~ ,tionData T VTypeData VIn~tanr~Data N VAdapt-~r~ ~ cpace A VcrArgument L Used by a language B Used by a prop~tv browser V Used by a view or adapter The mc~ngs of the usage codes are as follow:
kW ageReadOnly Pr~rcrty has no ~ . '' ' set mdhod.
kW ageWriteOnly Prop~sty has no ~ a . '' ' 8d method.
kWsageDefaultProperty n;S~ ~ ' one proper~ of an object as the property to be assignet or read when the object itself appears in ~alue ~A~l~C
(or ~Is the recipicnt of an ~ ', ' ) .
kW ageProtected Specifies that this element of a class is a protected member.
kWsageThreadSafe This usage nsg specifies that this funcbon or method can be called bv multiple threads at the same time.

SUBSTITUTE SHEEr (RUL~ 263 WO 96/08'765 PCT/CA95/00513 kWs.. geStrict Prop~, arcument. tuncbon return, or mcthod return that must not be coerced bv normal langua~e ruies.
kWaageVarArg For functions or mnhods. indicates that no argument d---ip~ is available for it; the function or method should be called using the call as found in the scripted source. Note that function or method described as Itaving a variable mtmber of c may not be able to be exposed to oth~ object svstems.
kWsageCallerI~Owner This usage flag specifies that this fitnction rnum, mnhod return, or value returned m an argument is to be freed by the caller.
kWsageByRef ldentifies an argument vhich should actuaily be passed by address.
kWaageHidden Function~ method, argument, or property is suppiied by the G....~ 1. not by a user.
kWJageOptional Function or method arc~unenl can be omitted in call.
kW-~ageHa3Default An argument for which default value from the VcrArguntent should be passed in a cail if omitted from a call.
kW~ageValue Specified on thc arcument or a property sn vhich is to hold the actuai value for the propertv. This is oniy needed when the propertv sn takes multiple kWsageOut The arCQument is aaually a return from the function or method.
kW ageInOut The argument is an input to the function or method7 but may also be modified during the call.
kW~ageDynantic This usage specifies that this class definition may change between queries. That is, when the class is queried it may have more elements (propaties. methods, etc.) than vhen it vas first queried.
Elements can only be added not removed.
kW~ageDeleteNotify This spe~fies that ~hen an instance of this object is destroyed or fuliy ~' ' ' in this process space titen thc otha adaptas will be notified of this.
kW~ageCannotSubcla~ This c}ass cannot be s ' ' ' by a ianguage or a builda (howev~, it may be ' ' :~' in its native object system).
kW~ageDoNotCache This usage flag specifies that this top levd item shouid not be cached by any vie vs.
The sn of available, ~ ' usage codes is fairlv small. Usage codes must be ailocated by Visual Edge on lm as needed basis so that they do not overlap vith otha .,~ r . -Enum VTCallType This _ is used.to define the calling ._ required to call a method or function correctiy.On any given ~ ' ' some or all of the following calling - . - may overlap and provide the same . ' kVCallTypeC Cail the function with C calling . ~ This calling shouid be used for a function deciared vith no prototype in ANSI C or declared with a variable number of r ~
kVCallTypeAn~iC Cal] the function with ANSI C or Ct~ calling ._ This calling . should be used for a function declared with an ANSI C prototype and a fixed number of SUBSTITUTE SHEET (RUI.E 26~

W 0 96/08765 ~ PCTICA9S/OOS13 kVCallTypePa-~cal Csll the function with Pascal callin~ This calling ~. should be used for a function written in Pascal or dec1sred with Psscal calling: ~_ (i.e.
_pascal).
kVCallTypeInternal Call the function with ANSI C calling Cv.. -~1tiv~ -and theintanal call signature. The internal call signsture is as follows:
VcrCallExceptlon ~InternalCallSignature ( VE unctionData ~ funcData, unQigned paramCount, VTypeData ~paramType~, void ~params, VTypeData ~re ultType, VcrDataRef ~re~ult) funcData Function d~ r" for the call.
paramCount Number of paramTypes Types of the params Arrsy of pointers to the resultType Requested return tvpe.
result (Return) Pointer to the return vslue of the function.
The value for all ~ ~should be ~specified.. Hidden , - should also be included. If anv of the ~ _ csnnot be converted to the expected npcs or if ~he actual return tvpe of the function cannot be converted to the requested return n~pe, the function should fail and return an exception.
Enum VTSearchTy~e This i~s used to specify ho~,v to search for clas~s t~ v ent~ics. Object system adaptens ~should use this argument to ~ whether they should ma~e a possiblv long and complex Jh for the class or function or whdher they should simply lool~ locally for the class or function. T _ _ which supptlrt late binding of types and functions may initially perform a local search to see if there is curxntly a definition. At runtime they will th0 perf~rm a complete Jh if the class or function was not found at ~ parse time.
kVSearehAll Sesrch in every possible wav to find the item kVSearrhT.~ca 1 Only do a local search for the it~n; do not perform anv tune _ _ ~ r ~- t~ find the ite~
Enum VTSearchCase Ihis . is used to specify how to p~f~m name searches for class registry entTia. Object system adllpters and ~ ' ' of the class Kgistry entries should stlclnpt to support both modes of nsme sea~hing. If csse ~ ~ - ~_ searching is not possibk then all searches should be csse sensitive in~.
kVCa~eSensitive Name se~h is case sensitive.
kVCaseIn~ensitive Namc search is case ~. .
Enum VTClassTag This . g the major subclass of Vcrsa e to which a particular VcrBase instsnce belongs. This can be used to ~ ~ ~ the type of object Kturned from generic lookup in the class regislJy.
kVcrArgument kVcrCla~c kVcrFunction kVcrProperty SUBSTITUTE SHEEr (RULE 26~

WO 96108765 ~ ~ 'f PCT/CA9S/OOS13 .

kVcrType kVcrInstance kVcrException kVcrAdapterSpace kVcrViewSpace kVcrAll Enum VI~TypeSubclass This _ - :' the subclass of VTypeData to which 8 particular VTypeData instance belongs. This can be used to facilitate traversal of type trecs.
kVtmPointer kVtmObjectRef kVtmFunctionPtr kVtmStruct kVtmUnion kVt~Enum kVtmArray kVtmSequence kvtmvariableArray kVtmAny kV~ ~7que kVtmEI-n.i: tal kVtmAlias Enum VTExcep~ionType This e defines all yeneric cbss registry functioD callin~ ~ - r ~i kVExceptionUnknown Type of the exception is unknown.
kVExceptionCallFailed Type of the cxception is specific to the call support code.
Object adapters should return ~ r " with this tvpe when ' " , enors, etc. occur.
kVExceptionCalleeFailed The call was c . ' ' but the called function generated an exceptio~
kVExceptionNoRe~ources I ~ - resources were svailable to complete the call.
This can, for instancc, be generated by running out of m~nory.
kVExceptionBadParam One of the I could not be converted to the required type.
kVExceptionPar ~o~nt The number of ~ was incorrect.
kVExceptionP~:lObject Theobjectinstancetowhichthecallwasattemptedwss invalid.
kVExceptionCouldNotExpo.~e An object instance passed to the call W8S from a foreign object svstem could not be con~rQled into an instance from the nati~re object system.
Enum VTInt~l~efIype VTInternal~fTypedefinestbetypesofinternal. ~ toclassregislryentries:
k~rDirectRef . P~' - is directly to another item in the hierarchy.
kVT-oopRef Reference may f~rm a circularity.
VTObjectSystem VTObj ectSy~tem is defined as a 16 bit unsigned nu nber used to determine the oyect system adapter ~ with a type managa or class registry entry. This 11) is used bv the object svstem adapter to detennine any special hsntlhng ,. I . for its own objects and classes ersus classes and objects from anoth~ object svstem. It is also used to determine search criteria when querying the class registry.
VTObjectSy~tem ~s must be allocated by Visual Edge. The ~ ' object svstem IDs are kV~nyObjectSy3temand kVNoObjectSy~tem SUBSTI'rUTE SHEE~r (RULE 26) WO 96/08765 ~ PCT/CA95/00513 --5~--VTVersion VTVer~1on is defined as a 32 bit signcd number used for specifying the vasion numba of classes which have Ihe same name but diffaent , ' - A higha vasion numba irnplies a newa definition.
Negative vasion nurnbas are illegal. The constant kWercionNotSpecified is used durmg searches to specify that the highest vasion should be found.

SUBSTIl UTE SHEET (RULE 26~

WO 96/0876!5 ~ PCT/CA9S/OOSl3 Support Classes The support classcs provide support for other class registry clssses. The VcrHelp class is used to provide help ' on class regis~ entries and on object method and prop~~ calling e~ors.
VcrCallException p~ovides - r about whv a csll to a mcthod or propertv failed. An instsnce of VcrC~ xception mav contsin an instance of VcrHelp if thae is end user readable av~ulabk about the source of the problem. VcrDataRefis used when cslling methods and propaties to easily rnaintain a reference counted dats object so thst the data object will be dekted when ne~kd.
Class VcrHelp VcrHelp dkfines the clsss re~stry help interface. S ' ' of VcrHelp are intended to be ~ . ' ' to take advanta~e of each platform's native help svstem.
Public Members VcrHelp C~ ~ a VcrHelpobjecL
-VcrHelp Dc~ys a VcrHelp object.
Overridable Public Members De cription Retu~ns the textual d ?' of the o~ner object.
PutDe~crlption Set thc textusl s' pti for this he1p item.
Ha~Help Indicates wheth~ the item is able display help about its owner object Di~playHelp Display the help r ~' for the owner object.
VcrHelp Constructors VcrHelp() VcrHelp(VString de~cription) description D--- p' oftheownaobject.
C~ . a help support object. Thae is a - . ~ which takes a dL~.i, asits argument. This sets the default ~' -ip~ r ~
VcrHelp Dealluctor -VcrHelp() Destroys a belp support object. If a help object is added to a class registry or type rnsnager object the hdp object will be d~oyed whell its owna is deslroyed.
De;,cli~tion and PutDeswi~ion VString De~cription() void PutDe~cription(VString) The De~cription property st~s the tcm~ pL of the o~ner object. It carl be .~ . ' ~ ' irl ! ~ ' . for ir~Dce, to paform a dDic lookup of the A- - d ~ The d-- - p~ should be suitable for display to the and us~ or should be "" otherwise.
HasHelp bool_t ~CR~lp() SUBSTITUlE SHEEr (RULE 26~

WO 9610M65 ~ PCT/CA95100513 HaaHelp returns whether this object supports the native help system. If the return is true, VcrBase::DisplayHelp must be able to brin~ up the help about its owner object.
DisplayHelp void DisplayHelp() Di~playHelp brings up the nati-~e help svstem ' with ' about the owner object. If the object does not suppart help, ~ c~e 1 p should retuTn false.
Class VcrCallException VcrCallException is an abstract class which is uscd to return r ~- about a failed call to a function or method.
Public Members PutHelp Sets the help svstan object for-this exception.
Overridable Public Members Type Returns the nype of the exception.
Code Returns the error code for the exception. This is specific to the source of thc exception.
SourceName Returns the name of the source of the exception.
Help Returns the help system object for this exception.
Index Returns the index of the parameter which caused the exception (if any).
UserType Returns the exception type if this is a user defined exception.
UaerData Ret~ns the exception data if this is a user def~ned exception.
Help and PutHelp VcrHelp ~Helpl) void PutHelp(VcrHelp ~help) help Help for this ite~
The Help property stores the help systern object for this exception. The help system object provides d~ r ~- about this exception as well as the ability to display help frwn the ~ti~e help systan If the Help prop~rty is NI~LL then this exceptioll does not supp~t any help.
Type VTExceptionType Type() = O
Type ret~ns the type of the exception. This type can be translated into a Isnguage specific crror me~8e.
Code long Code() = O
Code returns a source specific error code. Unless the meaning of this ~alue is known for the source, this ~alue cannot be ~ t~.

SUBSTITUTE SHEEr (RULE 26~

WO 96/08765 ~ PCT/CA95/00513 SourceName vstring SourceName ( ) = 0 SourceName rcturns the name of the source of the exception. This mav be the name of an p1 object svstenL etc., or ~" if the ermr was detected inside class registry code.
Index long Index ( ) = 0 Index returns the index of the argument which caused the exception. This value is negative if the exccption t~pe does not apply to a particular ar~unent or the argwnent which cause the exoeption is unkno~n.
UserType VExeeptionData ~U erType I ) = 0 U erType retums ~hat t~pe of user deflned exception occurred. The data for the exception is retrie~red with U~erData.
UserDah const VcrDataRef &U erData ( ) = 0 UserData returns the data I ' with a user defined exception. The type of this data is the same as the type of the exception.
Class VcrDataRef VcrDataRef is an class ~-hich is used to mana~e .ef..~ to objects or data. The class is self e' ' ~ and will prop~ly dispose of the data when all VcrDataRef objects which referenoe the dats are disposed o~ Note that for the - '-' to worl~, all . ~ must be build froln the first reference to the data, not f~n the original data directly. Inten~lly the reference stores the number of f to an object in a tempo~ry location so that all VcrDataRef objects c~n access this.
Public Members VcrDataRef C~ ~ aVcrDataRef object.
Address Retums a pointer to thc data.
Type Retums the tvpe of thc data.
Value Returns the internal Walue.
PutPointer Sets the pointer to the data.
PutConstant Sets the ~lalue of the data to a constant.
PutCopy Sets this to be a copy of another data ref.
PutOwnership Sets the data's c.. ' for the r Contained Retums whether the dat~ is contuined in the reference.
WillDelete Returns whether the data will be deleted.
WillDeref Retur~s whether the object will be d.. ,f._.
VcrDataRef Constructor VcrDataRef ( vold ~dataPntr, VTypeData ~type, bool_t doDelete = FALSE, bool t doDeref = FALSE ) VcrDataRef ( Walue data, - VTypeData ~ type = 0 ) SUBSllTUTE SHEE~ (RULE 26~

-WO 96/0876~ PCT/CA95/00S13 VcrDataRef ( const VcrDataRef &copy) VcrDataRef() dataPntr Pointer to the dsts.
data Actual dats for the reference value.
copy VcrDataRef to copy from.
type Type of the dsts.
doDelete Delete the dsts when references goes to zao.
doDeref D~f .~ the object when .ef.. c - goes to zero.
Cc ~ a refc~ence object. If the dsts is provided stored in a Walue, the dsts must be conslant. If a Walue is p~vided snd type is zero, type will be initislized fr~tn the type stored in the Walue. Note thst this might lose anv aliss ' for the type of the dsta.
Only ' tvpes (no object pointers, pointers, structs, etc.) sre supponed in Waluec. If type is not aD object pointer doDeref is icnored snd UxFree w~ll be called on the data if doDelete is TRUE and the number of rcferences reaches zero. If type is an object point~, if doDelete is TRUE the deslructor for the class instance will be cdled when the reference count reaches zero. Other~se, if doDeref is TRUE, the release method of the class instance will be called. The , withno-c buildsanemptyreference.
Address void ~Address ( ) const Addre~.~ returns a pointer to the data. The point~ passed into the - I or to PutPointer is returned. If the reference is initialized with a constant from a Walue, a pointer to the data will also be returned howev~, the reference to the constant will return a pointer to a storage location inside itself. Thus, the point~ should not be used after the referellce Type VTypeData ~Type ( ) const Type returns the type of the data. This is the same as the value passed to the _ . or to PutPointer or PutValue.
Value Walue Value ( ) const Value returns the intd Walue storage if the data is a constant. If the data is a pointer, an invalid Walue will be returned. This method should only be called if I ~Contained returns TRUE.
~O~l~-void PutPointer ( void ~dataPntr, VTypeData ~ type, bool t doDelete = FAI,SE, bool t doDeref = FALSE) SUBSTITUTESHEET (RULE 26~

dataPntr Pointer to the dsta.
- type Type of the data.
doDelete Delete the data when ,f._~ goes tozcro.
doDeref D .. ~ the object when . ~f__ goes to zero.
- Resets a reference object. If type is not an object pointer doDeref is ignored and UxFree uill be called on the data if doDelete is TRUE and the number of .ef,.c reaches zero. If type is an object pointer. if doDelete is TRUE the destmctor for the class instance will be called when the reference count reaches zero. Othenvise, if doDeref is TRUE the release mcthod of the class instlmce uill be called. Any data that was ~ in the reference ~ill be handled jus;t as if this reference had becn dest~red PutConstant void PutConstant ( Walue data VTypeData ~type - O~
type Tvpe of the data.
dataPntr Poinkr to the data.
doDelete Delek the data when .~fgoes to zero.
doDeref D~.. f~_~ theobjectwhen. ~ goestozero.
Rc-sets a reference object. The data must be constant. If type is zero type will be initialized from the type stored in the Walue. Nok that this might lose anv alias ' for the t~pe of the data. Onlv ' ' ' t~pes (no object pointers, poinkrs, structs, etc.) are supporkd in Walue~. Anv data that ~vas ~ in the reference will be handled just as if this reference had been deslroyed.
PutCopy void PutCopy ~con~t VcrDataRef ~copy) copy VcrDataRef to copy.
Resets a reference objecL The ncw value of the rcfercnce is the same as that of copy. This ~ill point to the same data as copy unless copy was as Walue based VcrDataRef. In this case this VcrDataRef will contain a duplialte of the value in copy. Any data that was 1 in the rference will be hsndled just as if this refcrence had been destroyed.
PutOw~
void PutOwnership ( bool t doDelete ~ FALSE
bool t doDeref e FAI.SE ) doDelete Delete the data when r goes to zero.
doDeref D r the object when ._~ goes to zero.
PutOwnership changes the o. ' ., ' if the data is ., f~ ' If the data isstored in a Walue tbis method has no effecL This method will typically be used to talce ova o .. ' . of an object or data. The caller must be sure that the lifebme of the data will be longer than the lifeti~es of all . ' to iL
Is~o..~ ;d bool t IsContained ( ) const I sContained ret~ns wheth~ the data is a constant s20red in a Walue inside the reference.
~ .

SU85rlTUTE SHEE'r (RULE 263 WO 96/08765 ~ PCI/CA9S/00513 WillDelete bool t WillDelete() con~t WillDelete retums whether the data will be deleted when all .ef .~ to it disappear. This will rcb~n TRUE if the data is a constant stored in a W alue inside the reference.
WillDeref bool_t WillDeref() con~t WillDerefrd~Ds wh~er the ob~ect will be d..~,f... - ~ when all .~.f~ to it disappear.
lhis will return FA~SE if the data is a constant stored in a W alue inside the reference.

SUBSTITUIE SHEE~ (RULE 26~

WO 96/08765 ~ PCT/CA9SIOOS13 Base Classes These classes are the base classes for all dass registry entries. They provide the common mcthods and pr~paties which sre needed across most of the different classes. VcrBa e defioes the lowest com~non ~ for all class registry classes. It supports refexnce counting, hdp ' ~ etc. Many of its methods are pure virtual and sre i .' ~ ' in ' VcrToplevel is the base class for class registry items which cao be found directly in name spaces. It provides support for version ' _ of class registry entries and for . of view Class VcrBase Public ~ clacc of VIP~ ~y VcrBa~e is the base class for the all class regist~ dements and type d ,~ It provides methods and storagc for osme, type, usage, and hdp ' about the item. This base cl~ss also supports referenoe couoting for use in its derived clssses. Vcrsa e is not directly ' ' ~
~u~ d Members AcquireChild Asks the base dass to acquire a reference to a child.
ReleaseChi1d As~;s the base dass to rdease a reference to a dlild.
Overridable Pl~t. ~,hd Members ~ AcquireChildren Acquires intd refercoces to children.
Relea eChildren Rele~scs intaDal references to child~L
Public Members AcquireInternal Acquires an intanal reference to the object.
ReleaseInternal Rdeases an internal refereoce to the object.
PutOwner Chanees the owner of the object.
PutHelp Sets the help - r " object for this item.
Tag Rehlrns the tag ' ~-~ _ this item Overridable Public Me-~.b. ~
Name Returns the name of the itan Type Returnsthetype oftheitcnL
Usage Retums the usage f~gs for the item Owner Returns the owncr the object.
Help Returns the help ~ r oyect for this ite~
Obj eC~S~Jt em Returns the oyect syslan which m~ges this itcm Plùt~led Data Members VTAtomP itsName The n~ne of the itsm VTUsageCode itsU age The usage flags of the it~L
AcquireChild void AcquireChild( VcrBa e ~child, VTInternalRefType refType ~ kVDirectRef ) SUBSTmlTE SHEET (RULE 263 wo g6/08 765 ~ Q ~ ~ PCT/CAgS/OOS13 child Child to acquire the reference to.
refType Type of reference to acquire on the child.
This method acquires internal references on a children of the object. For instance. a class would add direct ,ef..~ to its methods, prop~ties, types, etc. This method should be called whenever a new child is added to the object and when AcquireChildrenis called The choice of refesence t,vpe to add to ch~ldren is as follows:
~ Direct intanal references are held bv ownas on their children and by items on their type objects. AcguireChild(kVDirectRef) adds a direct internal reference.
~ Loop intanal refernces are held by types on classes, functions, and oth~ types.
AcquireChild(kVLoopRef) adds a loop intenu~ rcference.
ReleaseChild void Relea~eChild( VcrBa~e ~child, VTInternalRefType refType bool t decRef = TRUE
bool t deleteSelf = TRUS) child Child to release the refercnce from.
refType Type of refaence to release on the child.
decRef ~_ reference coun~
deleteSel f Deletc self if reference count reaches zero.
Relea~eChild wjll remove internal references from a child of the object. This method should be called whenev~ a child is removed from the objert and when ReleaqeChildren is called.
AcquireChildren void AcquireChildren() ~ O
This method acquiles intc~Dal .~ f~ to all childrcn of the object. This method will only be called from AcquireInternal. For instance, a class would add dirct .cf .c to itsmethods, prop-rties, types, etc. The choice of reference type to add to children is as follows:
~ Direct intd ~ are held by ownas on their children and by items on their type objects. AcquireChild~kVDirectRef) adds a duect ~tem~ refe~cnce.
~ Loop inte~nal ._f are held by types on classes, functions, and oth~ types.
AcquireChild(kVLoopRef) adds a loop intenu~ reference.
ReleaseChildren void Relea~eChildren( bool t decRef TRUS
bool t deleteSelf = TRUS) ~ O
decRef D~ ~ ref~nce co~L
deleteSelf Dkle~ se~if refcrnce count ~hes zo~.
Relea~eChildren will ~move internal refer~nces from all of its children. This method will only be called from Relea~eInternal. The boolean v should be passed on to theRelea~eChild calls on the children. If deleteSelfisTRUEthejARelea~eChildren should can replace any pointer to its children with NULL. If deleteSelfis FALSE then Relea~eChildRef~ must not nonove the pointas to its child~n.
AcquireTn~n~l VTRefCount AcquireInternal( SUBSmUTE SHEET (RULE 26~

WO 96/08 765 PCT/C~9S/OOS13 -V~InternalRefType refType = kVDirectRef) - refType Type of reference to acquire to the object.
This method acquires an internal reference to the object. AcquireInternal returns the total number of extemal and int-rnal ~ Ç to the object induding the newiy added reference.
Inte~Dsl ,ef~_. are ~cf .c to the object ~,vhich are controlled inside the clsss registry hierarchy. Extemal reference are .ef..c to the object which are controUed outside the class regis~y hi-rsrchy. Intc~nal ~ f.,~c~ are used to avoid r ' in reference counts. This method is only called by AcguireChild. The choice of reference type is as follo vs:
~ Ex~~nal ...f~. are held only by the observ0 outside the class registrv. Acquire should be called to add an e~ernal .. f.,~
~ Direct intanal .ef~.c are held by own0 on their children and by items on theirtype objects. AcquireInternal(kVDirectRef) adds a direct intenu~ reference.
~ Loop internal .ef... are held by types on classes, functions, and oth~ types.
AcguireInternal(kVLoopRef) adds a loop int~n~ ref~ence.
RelesceTnt~rnsl VTRefCount ReleaseInternal( VTInternalRefType refType = kVDirectRef bool t decRef = TRUE
bool t deleteSelf = TRUE~
refType Type of refc-rence to acquire to the objecL
decRef rh reference counL
deleteSelf Dektc self if reference count rc-adrcs zao.
Relea~eInternal will ranove an internal referncc to the objecL The return value is the total number of exlanal and intelDal ' to the object whidh remaip.
Relea~eInternal wiU caU Relea~eChildRef~ wh0 nceuYSar,V. Relea~eInternal tslces csre of resolving circular .ef .. This method is only called by Relea~eChild.
PutOwner void PutOwner(VcrBa~e ~owner) owner The owner of this oyecL
PutO~ -r sds the owner of this oyecL The owner propaty is used to enable tracing up an inslance tree to the root type or class definition This method is r '1~ called by the ~ ' ~ ' ' ofVcrBa~e.
Help and PutHelp VcrHelp ~Help() void PutHelp~VcrHelp ~help) help Help for this ite~
The Help property stores the help systan object for this item. The help system object proiides di~ p~ r " about this object ss well as the abilitv to display help from the nati~re help syst~L ~the Help propaty is NULL th0 this i~n does not support any help.

SUBSrlTUTE SHEEr (RULE 26~

WO 96/0876~ PCTICA9S/00513 --~5--Name VAtomRef Name ( ) Name rctums the name of the object. The name was spccified as an argumcnt to the ~.
of the ' ' of VcrBas e.
Tag VTClassTag Tag ( ) const Tag retums the tag of the objccL The tag identifies which type of subclass of VcrBase that this objcct is. Each subclass rcdefincs this mcthod to provide the correct , ' Type VTypeData ~Type ( ~
Type rcturns the typc of the objcct. The dcfault , ' retu~ns NULL. This method must bc rcdefincd in cach of VcrBase ' ' where il is ,rl That is, VClas~Data should rctum a type which is an objcct reference to the class, VFunctionData should rcturn the return type of the function, VPropData should rcturn the typc of the propa~.
VcrArgument should return the typc of the argumerlt: VTypeData should rctum itself.
Usage VTUsagecode Usage ~ ) . U3age retums the usage flags of the objecL The usage fla~s were spccified as an argument to the_ ~t~.. ofthe ' ' of VcrBase.
Owner VcrBa~e ~Owner ( ) owner returns the VcrBase object which o~ns this object. For instance if a VFuncti onData is added to a VCla~ Data using VCl aY ~Data:: AddMethod, the owner ~ of the YFunctionData will be the VCla~ ~Data. The ' ' of VcrBa~e set the owna a ,, ., ' 'y usingVcrsa e: :PutOwrler. See PutOwner formore ObjectSystem VTObjectSyste~ ObjectSy~tem~) ObjectSystem returns the object system which manages this item. The default ,' ' for this method rcb~ns kVNoObjectSy~te~L V~Argument redefines this method to ~n the objcct sys~m of its own~.
Class VcrToplevel Public ~.rbrl~c~ of VcrBase VcrToplevel is the base clsss for clsss registry items which can be found directly in a name spacc. It stores spccific r " about the views that this item is found in as well as the ~rersion numoa of the item and its full name. This class is not directly i '' ~
Public Members Views Rcturns the views ~ hich refaence this item.
InView Returns whetha this class is alread~ in the spccified view trce.

SUBSTITUTE SHEEr (RULE 263 _ wo 96,08765 ~ ~ ~ 9 ~ PCT/C~9S/OOS13 AddView Adds a view to the list of i.f RemoveView Removes a view from the list of ~. f_c ~
UnmapSelf Removes the item from all views and its adapta.
Overridable Public Members Xa j orversion Rc~urns the major vasion of this item.
MinorVer~ion Returns the minor vasion of this itcm Type DefiI~ihons VTToplevelRefList VrRefList of VcrToplevel objects.
VTToplevelRef VrReference to a VcrToplevel object.
VTToplevelDict vAtomDictionaryofvcrToplevel objects.
Views VTViewList views ( ~ const Views returns all the view name spaces which currcntlv refaence this item. No two view name spaces from thc same tree can rcfaence the itcm at the same time.
InView bool t InView(Wiew~ -SpaAe ~node) const node A node in the view name space tree to check for.
InView returns w hetha the specified item is already found .. in thc vicw which o~ ns node. This method can be used to check whetha it is alreadv in the trec.
AddView void AddView (Wi~ - pace ~node) node Node in view to add AddView ~Idds a view to the list of views wbich reference this item. node is the actual location in the view at which the item can be found RemoveView void RemoveView(Wi~ t- -Space ~node) node Node in view to remove.
RemoveView removes a view from the li-st of views which reference this item. node is the actual locatian in the view ~t which the item can be found Unm~r~;elf void UnmapSelf ( ) Aclf unmaps the item from all vicws al~d fr~m its adapter. This has the effect of flushing this item out of the cachc. This can bc cslled on items to help control mcmory c This i . of this mcthod calls Ur~map on all attached views and on the adapter which owns this item.
MajorVersion VTVer ion MajorVersion ( ) SUBSTITUTE SHEET (RULE 263 WO 96/08765 ~ PCTICA9S/OOS13 MajorVer~ion returns the major version numba of the item. Ihe default .' return 0. This mdhod can be G._ ' ' in 5 ' ' to retu~n a valid major version numb~r.
MinorVersion VTVer3ion MinorVer~ion(~

MinorVer~ion retu~ns the minor version number of the item. Ihe default .' re~n 0. This method can be o._..~ in ' ' to return a valid minor ~ersion number.

SUBST TUTE SHEEr (RULE 26~

WO 96/08765 ~ 9 ~ PCT/CA95/OOS13 _ --~8--Exposed Classes These are the classes which are exposed to a user of the class registry. These classes defines the structure for class registry entries. VFunctlonData, VPropData, VCla~sData, VAdapt-~r~ -Cpace, arld Wi~ pace are abs~ct classes which are intended to be ' ' ' for each object svstem to be able to provide its special support. VcrArgument, V~xceptionData, and VInstarlceData can either be directly - ' or can be - ' ' i for specific purposes. VClassRegistry is directly ' '- and should not be ' ' ' The set of exposed classes also includes VTypeData which is defined in the T~ ' . section.
Class VcrArgument Public ~"bcl~cs of VcrBase VcrArgument instances specifv the v to class registry described me~hods.
Public Members VcrArgument Ce , a VcrArgument object.
Default Retums the default value of the ar~ument PutDefault Set the default value of the argument.
Type Dçfinitionc VTArgumentList VArray of VcrArgument objects.
VcrA,~ Constructor VcrArgument( VAtomRef name, VTypeData ~type, VTUsageCode ucode~ = O) name Narne of the ar~ument.
type Type of the Qne~t.
ucodes Usage flags for the ar~ument (if any).
C . '1 an argu~nent objec~ This object will typically be added to a VFunctionData using AddArgument after its creatio~
Default and PutDefault const VcrDataRef ~Default~) void PutDefault~VcrDataRef) T.he Default propaty stores the default value for the argurnent. This value will be used if the a~urnent is nd specified when the mdhod is cslld The default ~ralue will only be used if the a~urnent type is a ' ' ~ ' type.
Class VFunctionData Public "Jl,cl~cof VcrToplevel SUBSTITUTE SHEEr (RULE 26 - - -WO 96/08'765 ~ CT/CA9S/OOS13 VFunetlonData is an abstract class which descTibes a declared function (or method). It includes its name, ~ ren rn type, and eallable entry point. This object ean be used in class registry or type manager d p~ or a subelass ean be built for the explicit purpose of aiding function ealling in an a..' whieh does not provide internal support for direct function ealling. A method differs from a function in that a method should have a hidden first argument vhich is an object pointer. Ihis argument will be declared as a generic object pointer Thus, before executing the method (with VerCall), it is up to the ealler to pcrfonD the eolrect type cheeking on the first argumenL It is the ~ r " ~~'~J of the subelass of VFunetionData to add the hidden ar~ument for a method.
Public Members VFunetionData C~ ~6aVFunetionDataobject.
Equal Da~ whether this function definition is the same as the specifled one.
Overridable Public Members LoekAeee~s Checks whether this thread can eall the function.
UnloekAeeess Unlocks this thread's loek on ealling functial.
EunetionType Returns a type which ~ c a pointa to this type of fwlction.
I qMethod Retu~ns whetha this is a method.
Arguments Returns the list of , for the function.
Exceptionq Returns the list of ~ p~ the function ean thro~ .
EntryPoint Retums the eallable antry point for the function.
ValidCall Returns ~hetha the previous call was ~ -Type Defini~i~nc VTEunetionLi~t VArrayofVPunetionDataobjects.
VTFunetionP~e~fT.i et VrRefLi~t of VFunetionData objeets.
VTFunctionRef VrRe f erence to a VFuncti onData oyect.
VTEunetiorlDiet VAtomDietionary of VFunetionData objects.
VFunctionData Con~l-u~;lol VFunetionData ( VAtomRef name, VTUsageCode ueode3 = O ) name Name of the funetion ucodes Usage flags for the function (ifany).
C~ ~ ~ a funetion dc :, ARer the definition of the function is u~mplete it csn be stored in a elass or name space.
Equal bool t Equal (VFunctionData ~func) fune Funetion ~ i"b to compare to.
Equal will compare the two funetion ~'~ ip~ and retuTn bue if they Jre equal. For the two fu~lctions to be equal the names, reCurn types, usa~e codes, numbers of , ~ and cn--r of the function d p~ must be the ssme. Also the names, types, and usge codes of all must be equal. The help r " is not checked. This method is ealled by the type manager when e' E if two function pointa types are of equal types.

SUBSTITUTE SHEEr (RULE 26) WO 96/0876~ fi PCT/CA95/OOS13 LockAccess bool_t LockAccess (bool t wait) -wait Wait for lock to be released.
LockAcce-~s locks the VFunctionData so that no other tbreads may call the function at the sa~ne time. }f kWsageThreadSafe is specified on the VFunctionData th0 LockAcce~ ~ will alwavs return TRUE. If wait is TRUE and the function is currentlv locked then LockAccess will wait for the function to be released otherwise. LockAccess will return FALSE. If LockAcce "3 returns TRUE the VFunctionData:: Unl ockCall m~lsl be called later.
UnlockAccess ~ void UnlockAcces ( ) UnlockAcces~ unlocks the VFunctionData so that other threads may call the function. If kW ageThreadSafe is specified on the VFunctionData then UnlockAcces~ does nothing.
Func~ionType VTypeData ~FunctionType ( ) = 0 Returns a type which represents a pointer to function with this si~nature.
IsMethod bool_t I Method ( ~ ~ 0 Return whetha this object is a metbod of a class (i.e. it bas a hidden first ar~unent of t~pe object) or whether it is a function.
~'p,~
VTA~ y~ tList Arguments ( ) - O
Return the list of ~ v to this furlction. The list should nev~ have items added to it or removed from it after the function has been directly or indirectly entered in the class registry.
Excep~ions VTExceptionList Exception~ I ) = O
Re~n the list of _ , that this function can throw. This list sbould never be modi&ed by tbe calling code. A lanvuave is not reqlured to use this ~ r " When a function is called throuvb the Call metbod all necessary ~ r '- about the exception is returned. This method is used prim~ily for r ' ~ purposes. The list should never have items added to it or remo~red fi~m h aflsr tbe function has been directlv or indirectly entered in the class registry.

En~yPoint void ~EntryPoint ( V~ sData ~objCla = 0, void ~object = 0, void ~callObject = 0, VTCall~ype ~calltype = 0) = 0 SUBSTITLIIE SHEE~r (RULE 26~

ob j Cl as s Clsss of the object if this is a method.
ob j eet Object to v,hich this function will be applied (only valid v,hen r ~r~
is eslled on a method).
callOb j ect (Return) If this is a method and 'object' is valid, this will contsin the object to use ss the first argument to the call.
calltype (Return) Calling c for calling the function ~.ntryPoint returns the callable entry point for this funetion. If this is a method, the first srgument msy to used to do a d~msmic lookup of the entry point for the given object. This mesns that the entry point snd cslling _ ._ csn diff~ d, _ upon the object instsnce. The second srgument is used to return the object which will be used for the sctusl csll to the method.
If this is a method, its owner is a clsss. snd objClass is r~ot 0, then objClas3->Ca~tToBa~e will c "~, be cslled on the object. Otherwise, objeet should slresd~
hsve been eonverted to a pointer to the base class by ealling VClas ~Data:: CastTosase on the objeet.
ValidCall VerCal 1 ~Yeeption ~ValidCall ( VFuneti onData ~ f uneData, unsigned paramCount, VTypeData ~paramTypes, void ~params, VcrDataRef &re~ult ~ = 0 funeData Funetion d p~ for the esll.
paramCount Number of paramT ypes Types of the I
params Arrsy of pointers to the ~ -result Pointer to the return ~slue of the function.
VA1 i dcal 1 eheeks whether the previous call to the funetion produeed a vslid result. This mdhod should be .~ .' ~' in ' ' to eheek the return vslue snd output or in/out for exeeption ~ -Class VPropData Public s.~b.,~s of VcrBase VPropData is an abstraet elsss whieh deseribes 8 prop~ of a elsss. A pr~ is a nsmed sttribute of a elass whieh is aecessed ~ugh get and set accessor methods. A prop~r must define st lesst one of the two aceessor methods, "get", and 'Iset". The accessor methods ean hsve multiple , This is useful, for instsnce, when a property is setually a eolleetion of oth~ objeets whieh requires an index to seeess a psrtieulsr location in the c "
Public Members VPropData C~ I a VPropData object Ove~idable Public Members Loc)cAcces ~ Cheeks whether this th~d can call the functi~
UnlockAccesQ Unloeks this thresd's lock on eslling function.
GetMethod Returns the "get" method of the prop~tv.
SetMethod Returns the "set" method of the propert~.

SUBSTITUIE SHEEr (RULE 26~

WO 96/08765 ~ 9 i PCT/CA9S/OOS13 Type Defu~itions VTPropList VArray of VPropData ob~ects VPropData Constructor VPropData ( VAtomRef name VTUsageCode ucodes = o ) name Name of the property.
ucodes Usage flags for the propertv (if any).
C- ~ a property d The names of the accessor methods should be the name of the property preceded ~ith either _qet_ or ~et . This naming c ._ (from the CORBA C
language binding) allows properties to be accessed '~ across multiple class rcgistrv enabled ~
LockAccess bool t LockAcce~ (bool t waitJ
wait Wait for lock to be released.
LockAccea~ locks the VPropData so that no other threads mav access the propertv at the same time. If kWs ageThreadS af e is specified on thc VPropData then LockAcce s s will alwavs return TRUE. If wait is TRuE and the fmction is cunently locked then LockAcce~
~ill wait for the function to be released; othervise LockAcceq~ will return FALSE. If LockAcce~ returns TRUE the VPropData: :UnlockCall must bc called later. The default . locks both the gd accessor and the set accessor before returning.
UnlockAccess void UnlockAcce~
- UnlockAcce~ urJocks the VPropData so that other threads may access the property. If kWsageThreadSafe is specified on theVPropData then UnlockAcce~ does nothing.
GetMethod VFunctionData ~GetMethod ( ) - O
GetMethod returns the retrieval accessor mdhod for the proper~v. This method was instslled in the property as part of the _ ~ . If the return is NULL then the property is not readable.
This should always reO~rn the same value after its initial .. ~i SetMethod VFunctionData ~SetMethod ( ) O
SetMethod returns the stR~ge accessor method for the pr~paty. Tbis method was installed in the property as part of the: ~ If the return is NULL then the property is not writable.
Tbis should always return the save value afler its initial Class VInstanceData Public s~ of VcrToplevel VIn~tan--onata describes a n~ ned instance of a constant~ variable or class. The named instance may be installed in the class registry so that it is a genemlly available instance or so that it is specific to a class.
VIn~tanceData ~nav be if necessary. The usage fla~s specify whdher the instance is read only read write or write onlv. A constant is described as a read only instance.

SUBSTITUIE SHEEr (RULE 26~

WO 96/OM65 ~ PCT/C~9S/OOS13 Public Members VIn~tanceData C- , aVInstanceData objcct.
Overridable Public Members Value Rctluns the value of the instance.
~lolecled Members PutValue Sets the value of the instance.
Type Definition~
VTInat~n~--T-i st VArray of VInstanceData objects.
VTInstanceRefList VrRefList of VInstanceData obj~ts.
VTInstanceRef VrReference lo a VInstanceData object.
VTIn~tanceDict vAtomDictionaryofvInstanceDataobject V~stanceData Constructor VInatanceData ( VAtomRef name VcrDataRef value VTUsageCode ucode~ = O ) name Name of the instance.
value Value of the instance.
ucodes Usage flags for the instance (if anv).
C~ . a d ~ r '~ of a nasned instance.
PutValue void PutValue (VcrDataRef value) value Value of the s lstance.
Sets the value of the Da~ned instance. Tbis is intendcd to be cslled frosn ofVInatanceData which need to set the value of the constant after of the base class.
Value conat VcrDataRef &Value ( ) Returns the value of the nasned instancc.
Class VExceptionData Public ;,.~bcl~s of VcrToplevel ~r~A- ~tionData dcsc~ibcs a us~ defuncd cxc~ption. Thc a~ception snay be installed in the class sl gisl~y so that it is a gencrallv availablc exc~ption or so that it is ss.~ocific to a class. F~ ase ~ ~ by thcir nasncs. VExceptionData snay bc ~ it neces~y.
Public Members VExceptionData C- . a VExceptionData object.
Protected Members PutType Sets the t~rpe of the exces)tion.

SUBSTITUTE SHEE'r (RULE 26~

Type Definitions VTExceptionList VArray of VExceptionData objects.
VTExceptionRefList VrRefList of VExceptionData objects.
VTExceptionRef VrRef erence to a VExceptionData object.
VTExceptionDict VAtomDictionary of VExceptionData objects.
VExcepaonData Co~ uclo, VExceptionData ( VAtomRef name, VTypeData ~type, VTUsageCode ucodes = O ) name Namc of the exception.
type Type of the exception.
ucodes Usage flags for the exception (if anv).
C~ a d~.~ of a user defined exception.
PutType void PutType ~VTypeData ~type) type Type of the exception.
Sets the type of the user defined exception. This is intended to be called from $ ' ' of VExceptionData which need to set the type of thc exception after ' of the base class. The type of the exception should not be changed after it has first been retrieved.
Class VClassData Public subrl~cc of VcrToplevel VClas3Data is an sbstract class which des~ibes a class of object to the cbass ~gistry. Its def~ition provides support for quer~ing the set of propaties, methods, types, etc. which are owned by the cbss. The methods include a method, destructor method, and reference counting methods. Any of these methods can be leR undefined when d ' ~ a class. This class ~nay be ~' ' ~ directly, or VcrCodeclCla~ may be ~ ' ' ~ instead for object system adapters.
Public Members VClas Data C~ , a VCla ~Data objecL
Notif yViews notifies views that the cbss has changed.
Overridable Public Me~b~
BaseClass Returns the fust base cbss of the des~ibed class.
Ba~eClasJes Re~rns a list of all base classes.
Con tructor Reblrns the cbss's Duplicator Returns the class's copy . ; p~
De~tructor Returns the class's dcs~uctor ~' ~
AcquireMethod Returns1hed ir ofthecbss's~Acquire"method.
ReleaseMethod Rchlrns the !' 'p'' of the cbss's "Release" method.
Methods Retums a list of all the methods of the class or of all the methods which ha~e the specified Ge.
Properties Returns 8 list of all the p~ties of the class.
Types Retums a list of all the types of the class.
In.~tance~ Ret~ns a list of all the installces defined in the class.
Exceptions Returns a list of all the _~ , in the class.

SUBSTITIJTE SHEET (RULE 26~

W0 96/08765 ~ ~ PCT/CA95/OOS13 Method Returns the me&od of the specified name.
Property Returns the pr~perty of &e specified name.
DefaultProperty Returns &e default property of the described class.
Type Returns the type of &e specified name.
~ Instance Returns the instsnce of &e specified name.
Exception Ret~s &e exception of &e specified name.
CaqtToDirectsa3e Casts the object instance to a direct base class.
CastToBase Casts &e object instance to any base class inslance.
CastFromDirectBase Casts t&e object instance from a direct base class.
CastFromBa e Casts the object instance from any base class to this class.
SubclassOfObject Returnstheclassofthespecifiedobjectgiven&atitisa subclass of this class.
SubclassOf D~ whether &e class is a subclass of &e class which is an argument to this method.
SuperclassOf D~ -whe&er the class is a . .' of &e class which is an argument to &is me&od.
Type Definitions VTClassLiqt VArray of VClaq~Data objects.
VTClassRefList VrRefList of VClassData objects.
VTClassRef VrReferenceto a VClassData object.
VTClassDict vAtomDictionaryofvclassData objects.
VClassData Cons~uctor VClassData( VAtomRef name VTUs~geCode usagel name Name of &e class.
usage Usage fl~gs for &e class.
C~ ~ a ~t 'p'- of a clsss. The class may be a base dass, singly inherited, or multiply inherited.
A user of the class should obey &e following rul~ for d~, of an object . ' ' into its scope:
~ If the object was . . ' with Constructor t&e user should call Destructor (if defined) when ~
~ If &e object is ' ~ tlD~ugh a method or function call, then if the usage flags on &e ~ _ ' ' ' which ~' ' the object contain &e flags kW ~ageCallerIsOwner then the user should ca~ Destructor ~vhen ~" ~, ~ O&en-vise, when the object is ~ ' l AcguireMethod should be called and when the object is to be disposed of, ReleaseMethod should be called if defined.
It sho~d be noted that tbese methods (Con~tructor Destructor AcquireMethod ReleaseMethod) do not 11l need to be . ' ' by t&e object itself, but may be functions designed to ease the ~ _ . into the class registry. Constructor may ha~e any ~ _ ~ . but Deqtructor AcquireMethod and ReleaseMethod must have no ~ L or all t&e ~ _ must have default ~ralues.
NotifyViews void NotifyViews( short nummeths short nu~props short n~ es SUBSTITUTE SHEET (RULE 26~

W O 96/08765 PC~r/CA9S/OOS13 ~hort numin3ts, ~hort nl - Y cepts ) -nummeths Number of ncw methods in the class.
numprops Number of new pn~pa~tes in the class.
numtypes Number of new types in the clsss.
nutni nsts Number of new instsnces in the class.
numexcepts Number of new . -- -r b in the class.
NotifyView notifies all views of the class that its deftttition hss changed. This must be called whencv~ the class hss changed and there sre views on it slresdy. More r ~C ~'V, the vtews only need to be notified if the - ~-r ' has occurred sfter a contplete list of methods.
properties, types, instances, or _. r'i hss been rctrieved. Views need to be notified in case thcy are storing any specific ' about methods, properties, etc. for que~ytng purposes.
BaseClass VCla~Data ~Ba eClaa~ ( ) = 0 Ba eCla~ returns N~1LI, if the class is a base class; the base class if this class is singlv inheritod or thc first base class provided to the - , if this class is multiply inherited.
BaseClasses VTCla~Liqt Ba3eCla~e~ ( ) = 0 Ba~eCla e~ rcturns an cmpty VArray if the class is a oase class; a VArray , the ~ base class if this class IS singly inherited; or the array of base clssses p~ovidcd to the ~ if this class is multiply inherited. This srrav should not be modified b~r the caller.
Col,sl,u~lor VFunctionData ~Con~tructor ( ) = 0 Con~tructor retunts the ~ _ for the dcscribed clsss. The function retluned by Con tructor is not idcntical to the C~ . for an object. The clsss registr~ defined c . - is ~-r '~ for allocsting the objcct and it must t~n the ncw object. The class re~y d . for thc c i will hsvc a gcncric objcct re~trn type (type code kVTypeObjectPointer). It is possible thst there is no ~ ~ specified, in which csse Con~tructor will rebtrn NULL. The VFunctionData teturned bv this method does nothsve 1I hidden first srg~nent for the object instance. Thus, this VFunctionData should not be i to be 8 method.
Duplicator VEunctionData ~Duplicator ( ) ~ O
Duplicator ~trns the copy ~ for the described clsss. The function returned by Duplicator ts not identicsl to the C~ copy . for sn oyect. The class ~gis~y defined cop~/ _ . is ~ , ' k for sllocttting the object snd it must r.~rn the new object.
The clsss ~egist~y ~' p~ for the copy ~ wtll hsve a generic object t~rn t~pe (type code kVTypeObjectPointer). It is possible that there is no copy . ~ specified, in witich csse Copy will reb~rn NULL. The VFunctionData r~rned bv this method has ahidden first st~nent for thc object instancc to copy. Thus, this VE~unctionData is a method snd is not sitnilar to Con~tructor.
Destructor VFunctionData ~De~tructor ( ) = 0 SUBSTITUTE SHEEr (RULE 26) WO 96/08765 ~ PCT/CAgS/OOS13 De tructor leturns the destructor for the described class. This method must h'ave no l v or have default values for all ar,, The method retuTned by Destructor is not identical to the C~ destructor in that tbis one is ~- r '~ ~~ for ~ the actual free of the memor,v allocated for the object instance. It is possibk that there is no destructor specified, in which case De~tructor will retu n NULL. The rdurn from Destructor must be a method.
Acql~ireMedlod VFunctionData ~AcquireMethod ( ) = O
AcquireMethod retums the method used to add a reference to an instance of the class. This method must have no r, ' or all ' v must have default values. The retum of AcquireMethod mav also be NULL. The retum from AcquireMethod must be a mdhod If an object s,vstem does not inherently support reference counting the class registrv can prvvide support for instance based referenoe counting using utilitv classcs.
ReleaseMethod VFunctionData ~Relea_eMethod ( ) = O
ReleaseMethod re~Ds the method used to remove a ref~ence from an instance of the class.
n~is mdhod must have no O or all ~rt ' must have default values. llle return of ReleaseMethod mav also be NULL. nhe rdurn from ReleaqeMethod must be a method.
Me~ods VTFunctionList Method~ ( ) = O
VTFunctionList Method_ ( VAtomRef name, VTSearchCaqe searcha~, void ~object = O) = O
name Name of the methods to search for.
searchas Search is either case sensitive or ' " '~.
ob j ect Object to use for a dvnamic search.
Method~ has twv v.. ' ' ' ~' "' If the version ~,vith no ~ ~ is called, the list of all I ~ r ~ methods in the class ~'---ip~' is retumed. nhe returned list must not be modified. This list will not contain any ~ available methods unless these have been added to the internal list of methods by a subclass of VClassData. The second version of this method finds all c.. ' ' ' methods of the given name. If an object is specified, a subclass of VClas qData mav use this to perform d,vnamic lookups of the method.
P~oye~lies VTPropList Properties ( ) - O
Properties returns the list of all ~ ' ~ ' p~paties in the class d---ip'' This list should not be modified by the call~. This list will not contain any d~ availablepropertia unless these have been added to Ule intemal list of propertia by a subclass of VCla~ ~Data.
Types VTTypeLi_t Types ( ) = O
Type_ retums the list of all ~"~ ~ r ~ types defined in the class ~' 'p~' This list should not be modified by the caller. This list will not contain an,v d~ , available types unless thesehavebeenaddedtotheinte~allistofpr~pertiesb,vasubclassofVCla~qData.

SUBSTITUTE SHEE~r (RULE 26~

WO 96108'76!i ;~ PCT/CA95100S13 --7&--~nst~nres VTIn~tanc~ni~t In~tancec() = O
Instance~ returns the list of all named inslances defined in the class d~l r Note that thcse cannot be inslances of the class, but will be named constants used by the class. This list should not be modified by the caller. This list will not contain any ~ available instances unless these have been added to the intemal list of properties bv a subclass of VClassData.
Excep~ionc VTExceptionList Exceptions() = O
Exception~ retwns the list of all ~ fmod ~ r ~i defined in the class d "L This list should not be modified by the call~. This list will not contain any ~ 'Iy available e - -r ' unless. these have been added to the internal list of properties by a subclass of VClaa~Data.
Me~od VFunctionData ~Methodl VAtomRef name, VTSearchCa~e earcha~, void ~object = O) e O
name Name of the method to search for.
searchas Sea~hiseithercasesensitiveor object Object to use for a dvnamic search.
Method finds the first svailable method of the given name. If an object is specified, a subclass of v~l a ~Data mav use this to perform a d~amic lookup of the method.
p.,.l,y VPropData ~Property( VAtomRef na~e, VTSearchCase ~earchas, void ~object - O) = O
name Name of the property to search for.
searchas Search is eith~ case sensitive or .~.
object Object to use for a d.vrlamic search.
Propertyfinds the property of the given name in the class ~ ~ If an object is specified, a subclass of VC1 a ~ aData may use this to perform a dynamic loohlp of the p~tv. Unlike methods, there is no coDcept of ~. ' ' ' properties.
DefaultP'~
VPropData ~DefaultProperty(void ~object - O) ~ O
object Object to use for a dynamic search DefaultProperty finds the default propaty in the class ~ This is the p~perty which has been specified with the kW ~ageDefaultProperty usage flag. The ~ncept of a default prop~ty is supported in languages such as Basic. If an object is specified, a subclass of VC~ a~ aData rnav use this to perform a dvnEunic lookup of the p~perty.
Type VTypeData ~Type( vAtomRef name, SUBSTITUTE SHEEl' (RULE 26~
_ o ~ ~

VTSearchCase searchas, void ~object = 0) = 0 name Name of the tvpe to search for.
searchas Sesrch is either csse sensitive or ob j ect Objecl to use for a dynsmic se~h.
Type finds the type of the given nsme in the clsss d~..tAiu . If sn object is specified, a subc1sss of VClassData msv use this to perfonn 8 dvnsmic lookup of the type.
TncPn~e VInstanceData ~Instance ( VAtomRef name, VTSearchCase searchas, void ~object = 0) = 0 name Nsme of the instsnce to sesrch for.
s ea rchas Sesrch is eitha csse sensitive or i ob j ect Object to use for a d~nsmic search.
Instance finds the inst~ object of the ~iven name in the clsss ~' ip If sn object is specified. a subclsss of VClassData mav use this to perform a dvnsmic lookup of the instance.
Note that this csnnot be sn instance of the clsss. but w ill be a named constant used by the clsss.
Exception . VExceptionData ~Exception~VAtomRef name, VTSearchCase searchas, void ~obj ~ 0) - 0 name Name of the exception to search for.
searchas Search is either csse sensitive or il ob j Object to use for a dvn~nic search.
Exception finds the exception of the given name in the clsss A~ p' If an oyect is specified, a subclsss of VCla Data may use this to perfonn a d~n~nic lookup of the r i CastToDirectR~ce void ~CastToDirectBase ( VCla~ Data ~ba~e, void ~ ob j ect ) base Bsse clsss to cast to.
ob j ect A pointer to the object instance to cast CastToDirectBa e reblms the new object pointer which can be used directly in method calls to the specified bsse class. The default . ' ~ns object unless ba~e is not direct bsse clsss. The default .' ~ill bc sufficient for most object systems.
However, for C~ ~vith multipk base classes, a different object pointer must be retumed for esch base clsss. If the base clsss is not found in the list of bsse clssses, this method should ~t~n NULL.
CastToBace void ~Ca3tToBase ( VClassData ~base, void ~object) SUBSTITUIE SHEET (RULE 26) WO 96/08765 ~ PCT/CA9S/OOS13 base Base class to cast to.
object A pointer to the object instance to cast.
- castTosaqe returns the new object pointer which can be used directlv in method calls to the specified base dass. The base class spccified mav be an,vwhere up the hierarchv. The default . ' ' finds a path to the base class and calls CastToDirectBase for each level of the hierarchy. The default ' , ' can be replaced by an adapter defined subclass to be more efficienL If the base class is not found in the hierarchv of base classes, this method should retu~n NULL. This method performs preorder traversal of the tree to find a path to the specified base class.
C~tFromDirectB~e void ~CastFromDirectBase( VClaqsData ~base void ~object bool t safe) base Base class to cast from.
object A pointer to the object instance to cast.
safe Perform type safe csst.
CastFromDlrectBa e returns the new object pointer which can be used directly in method calls to this class. The default , ' -' returns object unless base is not a direct base class. The default ' . ' ' will be sufficient for most object systems. However, for C~
with multiple base classes, a different object pointer .,~ each base class instance. If the base class is not found in the list of base classes, this method should return NULL. Ifsafeis TRU13 then this method should return non NULL only if the cast can be ~ ' -' as a t,vpe safe casL The default . ' retums NULL if safeisTRUE.
Ca~lFro.. .Rqce void ~CastFromBase(VClassData ~base void ~object bool t safe) base Bsse class to csst fronL
obj ect A pointer to the object instance to cast.
safe Perform type safe casL
Ca_tF.~ ~-qe returns the new object pointer vhich can be used directly in method cslls to this clsss. The base class specified may be Jn,vwhere up the hierarchy. The default . ' ' finds 1I path to the base clsss and cslls CastFromDirectBase for each level of ~he hierarchy. The default ' . ' ' csn be replaced by an adapter defined subclass to be more efficienL If the base class is not found in the hierarchy of base dasses, this method should return NUIL. ~f safeisTRUE then this method should return noa NULLonly if the cast csn be F r ~ as a type sllfe cast. The default ' .' ' returns NULL if safe isTRUE. This method perfanns preorder trav~s~ll of the tree to find a path to the spccified base class.
Subc!~c~OfObject V~l~q nata ~S--h-la~sOfObject(void ~object) SUBSTITUTE SHEE'r (RULE 263 WO 96/08765 ~ PCT/CA95/OOS13 -ol-object (Input & Return) A pointer to the object to narrow.
Given that objectis an inst~nce of the described class or of a subclass of the described class, Subcla~OfObjectwill narrow the object by returning the subclass ~ to which the object belon~s. If the subclass cannot be ~' ' then the return should be the current class ~'~~~ip~ pointer. In certain cases the . ' of VClassData mav deterrnine that the object can be more efficiently ~'r ' ~ by another pointer. In these cases the input object pointer may be modified. The csller of Subcla~OfObject should use the modified object pointa in all ' , - calls to methods of the class re~istry and methods of the object itself.
SubclassOf bool t Subclas~Of(VCla~3Data ~other) other Clsss to use in hierarchy check.
Subclas-~Of ~wns whether this described class is a subclass of the class described bv other.
SuperclassOf bool t Supercla~sOf(VCla sData ~other) other Class to use in hierarchv check.
Supercla3sOf returns ~vhetha this described class is a . ' of the class descibed bv other.
Class VAdapterNameSpace Public ~l~bcl~cc of VcrToplevel VAdapterr~ -Cpaceis an abstrsct class vhich should be ' ' x' by each object svstem adapter.
This class provides the interface bet veen sn object system snd the clsss registry. The object svstem sdapter should, through ! ' ' ', of class registry objects, provide an interface betwecn its native format for item ~' , snt the clsss registry d--- p~ of items such as classes and methods. The sdspter should provide a r~me space hierarchv to the class registry which is ss close ss possible to its native hierarchy.
Public Members VA~apterU -Space C- , sn sdapter rL~ne space objecL
Overri~ble Public Meml ers SubSpace Reb~rns the Dame space of the specified name.
Cla ~ Returns the clsss of the specified name.
Function Returns the function of the specified name.
Type Returns the type of the specified D~me.
In tance Returns the insl~nce of the spec~fie~
Exception ReturDs the exception of the specified nsme.
Cla Je~ Returns the clssses of the specified n~ne.
Function~ Returns the fum tions of the specified name.
Type Returns the types of the specified nsme.
In~tance~ Retwns the instsnces of the specified nsme.
Exception~ Retwns the ~ -- -r" of the specified name.
All Re~rns every item of the specified nsme.
Enumerate r items in the name space.
Unmap Umnsps sn item fr~n this sdspt~.
UnmapAllFromTree Unmaps all items fr nn the cache.

SUBSTITUTE SHEEr (RULE 26~

WO 96/08765 ;~ PCT/CA9S/OOS13 Removed Notifies the adapter that it has been r~noved from the class registry.
Type Defini~ion~
VTAdapterLi s t VArray of VAdapt P r~- - cpace objects.
VTAdapterRefList VrRefList of VAdapterNameSpace objects.
VTAdapterRef VrReferencetoaVAdapter1U~ spaceobject.
V~ pt~r~lameSpace Constructor VAdaptPr~ -Cpace ( VAtomRef name VTU ageCode usage ) name Name of the name space.
usage Usage flags for the nsme space.
C~ ~ an adapta name space. This class is used as the hse class to object system adapters for the class registry.
SubSpace VTAdapterRef SubSpace ( VAtomRef name VTSearchCase sca-~e = kVCaseSensitive VTSearchType ~-earch = kVSearchAll unsigned short depth 1 ) = O
name Name of name space to find.
scase Scarch is either case sensitive or search Type of search to pcrform.
depth Numba of name spaces layers to sarch into.
S- ~hSp~ ~-e finds the nested nsme space of the specified name. If the depth r _ is I only the top level n~nne space will be search~
Class VTCla'SP~Pf Class ( VAtomRef name VTSearchCa~e scase - kVCaseSensitive VTVersion major ~ kWersionNotSpecified VTVersion minor - kWeraionNotSpecified ~ VTSear. I~ .e search - kVSearchAll unsigned short depth - 1 VÇlA.~sData ~last - O) - O

SUBSTITUTE SHEE'r (RULE 26) name Name of class to find, scase Search is either case sensitive or ' " ~
major Ma~or version number to find.
minor Minor version number to find.
search Type of search to perform, depth Number of name spaces lavers to search into, last Last found highest version number.
Clacs finds the class of the spccified name. If either of the version numbers is not specified then the item with thc highest version number is chosen. If the depth parameter is I o~ly the top level name space will be searched. If a version of the item has alrcadv becn found, it should be passod into this method as the pa~meter last to use in internal . ' of vcrsion numbers, Funcaon - VTFunctionRef Function~
VAtomRef name VTSearchCase scase = kVCaseSensitive, VTVersion major = kWerslonNotSpecifiet VTVersion minor = kWer~ionNotSpecified VTSearchType search = kVSearchAll unslgned 3hort depth VFunctionData ~last O) = O
name Name of function to find.
scase Search is cithcr case scnsitive or ' ' ' major Major version munber to fin~
minor Minor version number to find.
search Typc of search to perform.
depth Numbcr of namc spaces la,v~s to search into.
last Last found highcst version number.
Function finds the function of the specified name. If either of the version numbers is not specified then the item with the highest version number is chosen. If the depth paramaer is I
only the top level name space will be searched. If a version of the item has alread,v been found, it should be passed into this method as the parameter la~t to use in internal; . ' of version numbers.
Type .eRef Type( VAtomRef name VTSearchCase scase e kVCa~eSen~itive V~Version major - kWersionNotSpecified VTVer~ion minor - kWersionNotSpecified, VTSea.c.ll~yl e search kVSearchAll unsigned ~hort depth VTypeData ~la3t = OJ - O

SUBSTITUTE SHEET (RULE 26~

~ f~
WO 96/08765 ~ ~ PCTICA95/00513 name Name ot tvpe ~o find.
scase Search is either case sensitive or ~ .
rna j or Major verslon number to find.
minor Minor version number to find.
search Type of search to perfonn.
depth Number of name spaces lavers to search into.
last Last found highest version number.
Type finds the type of the specified name. If either of the version numbers is not specified then the item with the hi~hest version number is choserL If the depth I is I only the top level name space wi11 be searched. If a version of the item has alreadv bea~ found. it should be passed into this method as the pa ameter la~t to use in internal - . of versjon numbers.
Tn~t~nce VTInstanceRef Instance ( VAtomRef name, VTSearchCase sca~e = kVCa~eSensitlve VTVer~ion major = kWer~lonNotSpecified VTVer3ion m nor = kWersionNotSpeclfied VTSearchType search = kVSearchAll unsigned short depth = l VInqtanceData ~la--t = 0) = O
name Name of instance to filKi s ca s e Search is either case sensitive or i - ~ .
ma j or Major version number to f~
minor Minor version number to f~nd.
search Type of search to perfonrL
depth Number of name spaces layers to sea~h into.
last Last found highest version number.
Instance finds the instance of the specified name. If eith~ of the version numbers is not specified then the itan with the highest version number is chosen. If the depth pa~ametar is I
only the top kvel name space wi11 be searched. If a version of the item has alreadv been fou~d it ~ should be passed into this me~hod as the pa~mder last to use in internal . of vasion numbers.
Excep~on VTExceptionRef Exception ~
VAtomRef name VTSearchCaYe scase - kVCaseSensitive, VTVersion major - kWersionNotSpecified VTVersion minor - kWersionNotSpecified VTSea~. hT~I.e search - kVSearchAll, un.~igned short depth - 1 VExceptionData ~la t - 0) e 0 SUBSTITUTE SHEEr (RULE 26~

WO 96/08765 ~ n ~ ~ ~ PCTICA9S/00513 -8~-name Name of exception to find.
scase Search is eitha case sensitive or ~.
ma j or Major vasion numba to find.
minor Minor vasion numba to find.
search Tvpe of search to perform.
depth Numba of na~ne spaces lavas to search into.
last Last found highest vasion numoer Exception finds the user defined exception of the specified name. If eitha of the version numbers is not specified then the item ~ith the highest vasion number is chosen. If the depth parameter is I onlv the top level name space ~ill oe searched. If a vasion of the item has already been found, it should be passed into this method as the parameta last to use in internal of version numoas.
Classes VTCla~3RefList Classes ( VAtomRef name, VTSearchCase scase = kVCaseSensltive, VTVer~ion major = kWersionNotSpecified, VTVersion minor = kWersionNotSpecified, VTSearchType search = kVSearchAll, un igned short depth = 1 ) - 0 name Name of classes to find.
scase Search is eitha case sensitive or ~. .
ma j or Minimum rnajor vasion numba to find.
minor Minimum minor vasion number to find.
search Type of search to paform.
depth Number of n~ne spaces layas to search into.
Clas es finds all versions of class of the specified name. ~eith~ of the ~asion numbas are specified, all items vith version numbers greata than or e~qual to numbers specified are retusned.
If the depth parameter is l only the top level name spaoe will be sesrched.
F~~nc,hQnc VTFunctionRefLi t Functions ( VAtomRef name, VTSearchCa e scase ~ kVCaseSensitive, VTVer lon major = kWer ionNotSpecified, VTVersion minor = kWer ionNotSpecified, VTSearchType search = kVSearchAll, urLsigned ~hort depth ~ 1 ) = O
name Nsmc of functions to find.
s cas e Sa~n:h is either csse sensitive or ~ .
rna j o r M- nurn major vession number to find rAinor Minimum minor vasion number to find.
search Type of search to perforrn.
depth Nurnber of name spaces lavers to search into.
Functions finds all ovaloads snd vasions of the function of the specified naune. If eitha of the vasion nurnbers are specified, all items with vasion numbas greata than or equal to nu~nbers specified sre rehlrne~ If the depth pammeter is I onlv the top level name space be searched.

SUBSTITUTE SHEE~ (RULE 26~

Types VTTypeRefLi~t Types ( VAtomRef name, VTSearchCase scase = kVCaseSensitive, VTVersion major = kWersionNotSpecified, ~ VTVer~ion minor = kWersionNotSpecified, VTSearchType search = kVSearchAll, unsigned hort depth = 1 ) = O
name Name of types to find s case Sesrch is eitha case sensitive or i ~.
ma j or Minimwn major version nwnber to find.
minor Minimum minor version number to find.
search Type of search to pafonn.
depth Nwnber of name spaces layers to search into.
Types finds all versions of the type of the specified nP ne. If eitha of the version nwnbers are specified, all items ~vith version nwnbers grellter than or equal to nwnbers specified are re~rned.
If the depth p~rameter is I only the top kvel name space will be searched.
Instances VTInstanceRefList Instances ( VAtomRef name, VTSearchCase sca e ~ kVCaseSensitive, VTVer~ion major r kWersionNotSpecified, VTVersion minor = kWersionNotSpecified, VTSearchType search = kVSearchAll, unsigned hort depth ~ O
name Name of inst~ces to find scase Sesrch is either ccse sensitive or ._.
ma j or Minimwn major version nwnber to find.
minor Mirwnwn minor version nwnber to find search Type of sesrch to pcrform.
depth Numba of nsme spaces l~yers to sa~ h into.
In~tances finds all versions of the instance of the spocified name. Il either of the version nwnbers sre specified, all items with version nwnbers ~rcater th~n or equal to nwmbers specified sre ren~ned. If the depth ~ is I only the top level name space will be sesrched.
Exceptions VTInstanceRefList Exception ( VAtomRef name, VTSearchCase sca e ~ kVCaseSen.~itive, VTVer ion IDajor - kVVersionNotSpecified, VTVersion minor e kVVer~ionNotSpecified, VTSearchType earch = kVSearchAll, unsigned hort depth ~ O

SUBSTITUTE SHEEr tRULE 263 wo 96/08765 ~ PCT/CAgS/OOS13 name Name of - r- ' tO find.
scase Search is either case sensitive or - ~ .
ma j or Minimum major version number to find.
minor Minimum minor version number to find.
search Type of search to perform.
depth Number of nan e spaces lavers to search into.
Exceptlonr~ finds all versious of the user deGned exception of the specified name. If either of the version numbers are specified all items with version numbers greater than or equal to numbers specified are returned. If the depth parameter is I only the top level name space will be searched.
All VTToplevelRefList All ~
VAtomRef name VTSearchCa~e acase = kVCaceSen~itive VTVer ion major = kWersionNotSpecified VTVer~ion minor = kWersionNotSp~cified, VTSearchType search = kVSearchAll un igned short depth = 1 ) = O
name Name of itans to find.
scase Search is eitha case sensitive or i t~,.
ma j or Minimum major vasion number to find.
minor Min~num minor version number to find.
search Type of search to perform.
depth Number of name spaces layers to search into.
All finds aU different items (classes functions t~pes etc.) of the specified name. If either of the version numbas are spocified all it~ns with vasion numbers greata than or equal to numbers specified are relurned. If the depth parameter is I only the top level name space will be searched.
F.nllmerate void Enumerate ~
VTAdapterFn- ~,c func void ~ context VTCla~Tag type = kVcrAll VTSearchType ~earch = kVSearchAll) ~ O
func Function to call for each item.
context Context r " to pass into; function.
search Type of search to perform.
Enumerate . aU items of the specified type. If type is kVcrAll then all items are Enumerate does not . any items in nesled name spaces. For each item found the - fuuction is called with the ~ context and the item itself.
Unmap void Unmap (VcrToplevel ~item) - O

SUBSTITUT;E SHEEr (RULE 26~

WO 96108765 ~ PCT/CA95100S13 item Item to unmap from the view.
Urlmap UlllllapS 8 particular item from the eache of this adapter. The adapter should remove all reference to the item and remove it from its eache. This method ean be applied both to adapt~
name spaces and oth~ items.
UnmapAllFromTree void UnmapAllFromTree() = O

Unmap~llFromTree unmaps all items found .~ in this name spaee from the eache of this adapter. The adapter should remove aD referenee to the items ar~d remove them from its eache. This method ean be applied both to adapter name spaces and other items.
Removed void Removed() = 0 Removed is ealled by the elass registry on the top level adapter name spaee to notifv the adapt~
that it has been ramoved. The adapta should not unmap its items and name spaces from vievvs;
the views will do this. AHa calling Removed the class registry will release its reference to the adapta which should than delete the adapta.
Class WiewNameSpace Public subçl~cs of VcrToplevel wi~ ~ -Cpace is an abstract class which ,.J,.~ - a user defined view of class registr~ items.
VAdaptD-~ -Sp~ee~ define the actusl hiaarchy of names where each object svstem is, in itself, a separate n~ne space from other object systems. Each object systan may in turn contain sub name spaces.
Ihis ~,.. ' ~ ' hiersrchy of names may not reflect how the end usa chooses to view the physicaDy different name spacoe. For i~lstance, the usa may wsnt aD top level namoe to be in the same name space;
or, a la~ge such as Basic may prefer to have a &t name space to work with. These goals can be .' ' ' us~g Wi~ Spac~ Wiew~3 -Space providoe the user defined mapping betveen the physical hiaarchy of names and the user's view of the hiasrchy of names. Multiple WiewNameSpace I _' rnay exist for sny physical hiasrchy. Wie~t~- -Space also acts as a csche for it~ns which sre re~rieved from the adapter name space. Once items have been retrieved from the adapter ru~me space, they ean be ~ved sround in the view hiersrchy without affecting eode which uses than A view may be . ' ' in persistent storage. To save where each ' ~ ' ' itan in the view csme from, the vie v can find the fully qualified name of an item by tracing up the adapter name spaee hierarehy using VcrBa~e::Owner. When restoring itself the view ean rebuild the objects by quaying each kvel in the fully qualified name for the next item in the ne.
Public Members Wi_ ~- -Space C ~ a view nsme spaee.
Di~tanceTo Ret~ns the distanee to snother new in the tree.
DirectlyInView Returns whether the item is directly in this view.
ViewOfObject Returns the view which contains the objecL
Ovemdable Public Members Toplevel Returns the top level view in this hiaarchy.
SubSpace Returns the narne spaee of the specified narne.
Cla ~ ~ Returns the cl~ss of the specified name.
Function Ren~ns the function of the specified rlame.
Type Returns the type of the specified name.
In~tance Returns the ins~nee of the specified.

SuBSrlTuTE SHEE'r (RULE 26) WO 96/08765 ~ t) t~ ~ ~ PCI/CA95/OOS13 Exceptlon Returns the exception of the specified name.
Cla~ses Returns the classes of the specified name.
Functions Returns the functions of the specified nsme.
Types Returns the types of the specified n~une.
Instances Ret~ns the instances of the specified name.
Exceptions Returns the ~. of the specificd rlame.
All Returns everv item of the specified name.
Enumerate r ~.~ items in the natne space.
MappedAdapters Returns the list of adapters which sre mapped onto this view.
Map Maps an itan into ~his view.
Unmap Unmaps an it~n from this view.
UrimapAll Ur~nsps all adapter specific items from this view.
UnmapAllFromTree Unmaps all adspter specific items from this view and all contsined views.
Cl assChanqed Notifies the view that a class in it hss changed.
AdapterAdded Notifics the view that a new adapter has been inst~lled in the clsss registr~s AdapterRemoved Notifies the vie~ that an adapter has been re~noved from the clsss re~istr!
Removed Notifies the view that it hss been removed from the class registn~.
Type DefiI~i~ions VTViewList VArray of WiewN - cpace objects.
VTViewRefList VrRefList of WiewNameSpace objects.
VTViewRef VrReference tosWiewNameSpace objcct.
WiewNameSpace Constructor Wie r~r -Space( VAtomRef name VTU a~eCocl~ usage ) name Name of tbe Ds~nc spsce.
usage Ussgc flags for thc namc spacc.
C - an view name spscc. This class is used as thc basc class to . - ~ -views of thc clsss registry hiersrchy.
DistanceTo bool t DistanceTo ( Wi~ ~~ cpace ~other int ~distance ) other Other nsmc sp~lce in the trcc.
distanee (Rcblrn) Distance to the other na~nc spscc.
DistanceTo rctwns thc distsnce to another view in thc s~nc trec. Thc return is FALSE if this and other sre not in thc s~unc trec or if this and other src siblings. TRUE is rcturned if other is an ancestor of this or if this is sn sncestor of other. distance will be positivc if this is sn snccstor of other (i.c. other is fwtha down thc trce). distsncc will bc ncgstivc if other is sn sncestor of this. If this is equsl to other than the retwn will bc 0.
Directly~View bool t DirectlyInView (VcrToplevel ~item) SUBSTITLITE SHEET (RULE 26~

WO 96/08'76~ PCT/CA9S/00513 item Object to checlc.
- DirectlyInView returns whether item is contained directlv inside this view. The method will return FALSE unless itan is contained directly inslde this new.
ViewOfObject VTViewRef ViewOfObject (VcrToplevel ~item) item Object to check.
ViewOfObjectrcturnstheview=espaceinthisviewhierarchywhichcontainsitem.
Toplevel WiewNameSpace ~Toplevel ~1 = O
Toplevel returns the top levcl view in this hierarchv of view =e spaces. This ~ill be called oRen so it should be cached inside each nested ~iew name space. This method ~ill be called by VcrToplevel:: InView to determine if an item had alreadv been mapped into the parlicular ~ie~v hicrsrchy.
SubSpace VTViewRef SubSpace ( VAtomRef name, VTSearchCase scase = kVCaseSensitive, VTObjectSystem sy~tem = kVAnyObjectSy~tem, VTSearchType search = kVSearchAll, un~igned short depth = 1 ) = 0 name Namc of name space to find.
scase Search is either case sensitive or .~.
system O'bject svstem to do thc samh in.
search Type of search to perfomL
depth Number of =e spaces lavers to search into.
S~hSpace finds tbe nested =c space of the specified Dame. If tbe item is not found in the cache the ~iew should query each adapters which matches sy~tem for the it~n. If the depth is I only the top le~.rd =e space v,ill be searched [t is the . , ' ' ~ of the vie v to decide whether an item from an adapter can appear in multipk locations in a view. The method VcrTopLevel:: InView can be called on the iteln to check if it is al~ady in this vie v hierllrchy.
Class VTrl a~R~f Cla~ ( VAtomRef name, VTSearchCa e ca~e - kVCaseSensitive, VTObjectSy~tem sy~tem - kVAnyObjectSystem, VTVeraion major. = kWersionNotSpecified, VTVer~ion minor = kWer ionNotSpecified, VTSearchType ~earch = kVSearchAll, un~igned ~hort depth = 1, VCla.~sData ~last = 0) = O

SUBSTIrUTE SHEEr (RULE 26) name Name of class to find.
scase Search is eitha case sansitive or ~
~ system Object svstem to do the search in.
ma j or Major vasion number to find.
minor Minor vasion number to find.
search Type of search ~o perform.
depth Nwnba of name spaces lavas to search into.
last Last found highest version numba.
Clas~ finds tbe class of the specified name. If eitha of the vasion nwnbers is nol sp~cified then the ite n with the highest vasion nwnba is chosen. If an item is found in the cache all itans with hiBher vasions are only checked if from the same adapta and adapter name space. Once the cache checks are complete and higha vasions still need to be found or the exact versioD is not fownd tban tbe Cu~_r t e (or all) sdapters name spaces should be checked If tbe depth panuneta is I only the top level name space will be searched. If a vasion of tbe itan has already been fownd it sbould be psssed into this method as tbe parameter la3t to use in intar~ . of vasion nwmbers. It is tbe ,~ tv of tbe view todecide wbether an itan from an adapta can appear in multiple locations in a vie~ The method VcrTopLevel:: InView can be cslled on tbe item to check if it is alresdy in tbis view hiaarchv.
Funchon VTFunctionRef Function ( VAtomRef name, VTSearchCa~e ~ca e = kVCa--eSen~itive VTObjectSy tem ~y~tem z kVAnyObjectSy3tem VTVer~ion major = kWersionNotSpecified VTVer3ion minor = kWer~ionNotSpecified VTSearchType ~earch = kVSearchAll un~igned ~hort depth VFunctionData ~last = 0) = 0 name Name of fwtction to find.
scase Search is dtb~ case se~sitive or ~ .
system O~ect system to do the sa~b in.
ma j or h~tjor version n ber to fmd.
rninor Minor version numba to find.
search Type of se~b to perf~L
depth N~nber of ~une spaces l~ers to se~ch into.
last L~tst found highest version nwnber.
Function finds the f~tction of tbe specified naune. If dtb~ of tbe vasion nwltbers is not spocified thelt the item with the Itigbest vasion number is chosa,. If an item is found in tbe cache all ~ ~ . items with higher versi0ts are only cbeclced if fr0n the same sd~tpter ~td sdapter name space. Once the cache checl~s are complete aod higher verSions still need to be found or the a~act verSion is nd found thett tbe ~ r ~' _ (or all) sdaptas name spaces should be choc~ed. If tbe depth parsmeter is I anly the top levd ns~ne space will be se~
If a versi0n of the itan hss slr0dy becll folmd it should be passed into this method ss the psrameta la~t to use in intern~l . of versi0l numbers. It is the ~-r " ~'~ of the vic~v to decide whetha an itan fro~n an sdapta can appear in multiple locations in 8 vie v. The method VcrTopLevel:: InView can be called on the item to check if it is slready in this vicv hierarchy.

SUBSTITUTE SHEE~ (RULE 26~

WO 96/OM65 ~ Q ~ ~ PCT/CA95/OOS13 Type VTTypeRef Type( - ~VAtomRef name, VTSearchCase scase = kVCaseSensitive, VTObjectSystem system = kVAnyObjectSystem, VTVer~ion major = kWersionNotSpecified, VTVersion minor = kWersionNotSpecified, VTSearchType search = kVSearchAll, unsigned short depth = 1, VTypeData ~last = 0) = 0 name Nalne of type to find.
scase Sesrch is either csse sensitive or i ~
system Object system to do the se~h in.
maj or Major v~sion number to find.
minor Minor version nwnber to find.
search Type of sesrch to pe.-form.
depth Number of nsme spsces lavers to search into.
last Last found highest version number.
Type finds the tvpe of the specified n~ne. If either of the version numbers is not specified then the item with the hi~hest version number is chosen. If an item is found in the csche all n ' , items ~ith hi~her versions are only checked if from the same adapter and adapter name space. Once the cache checks are wmplete and higher versions still need to be found or the exaa version is not found then the w..~, ' G (or all) adapters name spaces should be checked. If the depth parameter is I only the top lcvel name space will be searched. If a version of the item has already been found. it should be passed into this method as the partuneter laqt to use in internal c . of version numbers. It is the l~~r " ''' ~ of the view to decide whether an item from an _dapter can appear in multiple locations in a vie v. The method VcrTopLevel::InView can be called on the item to check if it is already in this view hierarchy.
Tn~nre VTInstanceRef In~tanCe( VAtomRef name, VTSearchCase scase = kVCaYeSen~itive, VTObjectSy~tem system ~ kVAnyObjectSy~tem, VTVer~ion major = kWersionNotSpecified, VTVersion minor = kWersionNotSpecified, VTSeal~l~y~e search = kVSearchAll, un~igned short depth ~ 1, VInst-nrenata ~last - 0) - O

SUBSmUTE SHEE'r (RULE 26) WO 96/08765 ~ t) 9 1 PCI/CA95100513 name Name of instance to find.
scase Search is ath~ case sensitive or ~.
system Object svs~an to do the search in.
ma j or Major version nwnber to find.
minor Minor version nwnber to find.
search Type of search to perform.
depth Nwnber of name spaces lavers to search into.
last Last found highest versionnwnber.
Instance finds the instance of the specified name. If eith~ of the version nwnbers is not specified then the itc n with the highest version nwnber is chosen. If an item is found in the cache all ' ~ items vith high~ versions are only checked if from the same adapter and adapter name space. Once the cache checks are complete and high~ versions still need to be found or the exact version is not fownd thcn the cu..c r ' Ij~ (or all) adaptcrs nsme sps,cs should be checked. If the depth parameter is I only the top level name spacc vill be sesrched.
If a version of the item has alreadv been found, it should be psssed into this method as the panuneter last to usc in intemal _ . of versiJ/- nwmbers. It is the l.-r ' litv of the vie v to decide vheth~ sn item from an sdsptcr can sppear in multiple locations in a view. Ihe mcthod VcrTopLevel:: InView csn be called on the item to check if it is alrcsd~ in this vie v hier. rchy.
Excep~ion VTExceptionRef Exception ( VAtomRef nar~e, VTSearchCase ; case = kVCaseSensitive, VTObjectSyatem ayatem z kVAnyObjectSystem, VTVersion major = kWeraiorlNotSpecifled, VTVeraion minor --- kWersionNotSpecified, VTSearchType aearch = kVSearchAll, unsigned ahort depth e 1, VExceptionData ~last = 0) - 0 name N-me of cxceptio,- to find.
scase Sauch is either case sensitive ur system Object system to do the search i~
ma j or Msjur versi~A numbcr to find.
minor Minlr version number to find.
search Tyrc of ~rch to pafon~L
depth Nusnba of name spaces Isyers to search into.
1ast Lsstfoundhighestversiw numb~r.
Exception finds the n ser definod exccptio.-A of the specified name. If eith~ of the version mi nbas is not specified tben the item with the higbest versiun number is chosen. If an item is found in the cachc sU - , items ~nth higher versic,ns sre only checked if fro~n the sa ne sdspta s,-d sd-pta nsme spa,e. O~~e lhe cacbe checks are co~.nplete snd high~ versiu,-As still need to be found or the exsct vasion is not found th0 the w - r ' ~, (or all) adaptas nsme spaces should be checl~ed. If the depth I is I aDly the top level n-c_ne space w ll be searched. If a versiun of the itan hss slresdy been found, it should be p-ssed into this method ss the ~ laat to n se in intansl - . of vasiûn nu~nbcrs. It is the l~-r '~ of the view to decide whether an item from ~ n adapter can appear in multiple lo~tions in a view.
The method VcrTopLevel:: InView can be caUed on the item to check if it is alreadv in this vie~v hierarchy.

SUBSTITUTE SHEEr (RULE 263 , WO 96/0876~ PCTtCA9S/00513 Classes VTCla~aRefLi~t Cla~es( - VAtomRef name VTSearchCase sca e = kVCaseSensitive VTObjectSyatem y tem = kVAnyObjectSystem VTVeraion major = kWer~ionNotSpecified VTVer~ion minor = kWer~ionNotSpecified VTSearchType earch = kVSearchAll, un~igned short depth = 1) = 0 name Nsme of clssses to find.
scase Sesrch is eith~ case sensitive or system Object system to do the sesrch in.
major Minim msjor version number to find.
minor Minisnum minor version number to find.
search Type of seas~h to perfonn.
depth Nulnba of na~ne sps~es layers to search into.
Cla~e~ &ds all versions of clsss of the specified nasne. If either of the version numbas sre specified all itans with version numbas greata than or equal to numbas specified sre returned.
Once the local view checks sre complete lhal each ~napped sdspta mstching ~ystem should be checked. If the depth pssssneta is I onlv the top kvel nsme spsce will be searched. It is the 1~ r '~ of the view to decide whetha an item from an sdspta csn appesr in multiple lo~stions in a view. The method VcrTopLevel::InView csn be called on the item to check if it is alreadv in this view hias~hy.
Func~ions VTEuncti--nRefT-~t Eunction~
VAtos~Ref nasne VTSearchCa~e sca~e - kVCa~eSen~itive VTObjectSy~tem ~ystem = kVAnyObjectSy~tem VTVer~ion major kWer~ionNotSpecified VTVer~ion minor kWer~lonNotSpecified VTSearchType ~earch e kVSearchAll un~igned ~hort depth 1) - 0 name Nsmc of functiosls to &d.
scase Seorch is esther alse salsitive or . .
system Object systan to do the ~h in.
major. Mis~imum major vasiosl number to fisul minor Minisnum minor vasion number to find.
seareh Type of seluch to perf~L
depth Number of nssne spsces layers to search into.
Functions finds all ove~ioads snd velsions of the function of the specified nsme. If either of the ves~ion numbers sse specifiod all itans with vasion numbas grader than or elsual to numbers specified sre s~ Once the local vie v checlcs are co~nplete then each snapped sdspter snatching ~y~tem should be checked. If the depth psmmeter is I only the top level nsune space will be sess~hed. It is the ~ ~ of the view to decide whether sn item from an adapter csn appear in multiple lacations in a view. The method VcrTopLevel::InView can be called on the item to cha k if it is already in this view hierarchy.
Types VTTypeRefList Type~( SUBSTITUTE SHEET (RULE 26~

WO 96/08765 ~ PCT/CA95/OOSl3 vAtomRef name, VTSearchCase sca~e = kVCaseSensitive, VTObjectSy~tem sy~-tem = kVAnyObjectSystem, YTVersion major = kWersionNotSpecified, VTVersion minor = kWerelionNotSpecified, VTSearchType ~earch = kVSearch~1, unsigned short depth = 1 ) - 0 name Name of types to find.
scase Search is eith~ case sensitive or ~
system Object syste~n to do the sesrch in.
ma j or Minimwn major version nwnber to find.
minor Minimum minor version nwnber to find.
search Tvpe of search to perfor~
depth Number of name spaces layers to sesrch into.
Types finds all versions of the type of the specif~ed name. If eith~ of the version numbers are specified, all itans with version numbers greater thsn or equsl to numbers specified are retwned.
Once the local view checks are complete then esch mspped sdapter mstching sy tem should be checked. If the depth paramaer is I only the top level name space will be searched. It is the 1- r '~ of the vie v to decide whetha sn item fmn an sdapter can sppear in multiple locstions in a view. The method VcrTopLevel:: InView csn be cslled on the item to check if it is slready in this view hierarchy.
,es VTInstanceRefList Instance~ ( VAtomRef name, VTSearchCase qca~e = kVCaJeSen~itive, YTObjectSystem -~yJtem - kVAnyObjectSyqtem, VTVer~ion major e kWer~ionNotSpecified, VTVerJion minor - kWersionNotSpecified, YTSearchType earch - kVSearchAll, unJigned ~hort depth ~ O
name Nsme of instsnces to find.
scase Search is eitha csse sensitive or .~ .
system Object svstem to do the sesrch in.
ma j or Minimum major vasion n ba to find.
minor Minunum minor version n~nba to fm~
search Type of sesrch to pafomL
depth N~nber of e spsces Isyas to search into.
InJtances fmds all vasions of the instance of the spccified nsme. If eitha of the vasion mDnbers are specified, all itams with vasio~ numbers grellta thsn or equsl to numbers specified ~re returned. Once the local view checl~s are complete ~ each mspped sdapta mstching JyJtem should be checlced. If the depth parameta is I only the top level nsme space will be searchd lt is the ~ r ~ of the vie v to decide whdha an item from sn sdapter cansppesr in multiple locations in a view. The method VcrTopLevel:: InView csn be cslled on the item to checlc if it is already in this view hia~lrchy.
Excep~ons YTExceptionRefList Exceptions ( VAtomRef name, VTSearchCase scase = kVCaseSensitive, SUBSTITUTE SHEET (RULE 26~

WO 9610M65 ~ PCT/CA9S/00513 VTObjectSy tem system = kVAnyObjectSystem VTVersion major = kWersionNotSpecif1ed VTVersion minor = kWer~ionNotSpecified VTSearchType search = kVSearchAll uns i gned short depth = 1 ) 0 name Name of . ~ f.~ to find.
scase Search is either case sensitive or ~
system Object svstan to do the search in.
ma j or Miliunum major version number to find.
minor MilLunum nunor version number to find.
search Type of search to perform.
depth Number of name spaces layers to search into.
Exceptions finds all versions of the user defined exception of thc specified name. If either of the version numbers are specifial. all items with version numbers grcater than or equal to numbers specified are returned. Once the local view checks are complete then each mapped adapter matching sy~tem should be checlced. If the depth r - is I only the top kvel name space will be searched. It is the l--r '~ y of the view to decide whether an item from an ad~er can appear in multiple locations in a view. The method VcrTopLevel:: InView can be called on the iteln to check if it is alreadv in this view hierarchv.
All VTToplevelRefList All ( VAtomRef name VTSearchCase scase kVCa eSensitive VTObjectSystem system ~ kVAnyObjectSystem VTVersion major = kWer~ stSpecified VTVersion minor = kWersionNotSpecified VTSearchSype search e kVSearchAll unsigned short depth ~ 0 name Na~ne of items to fuld.
scase Search is either case sensitive or ~
system Object system to do the search in.
ma j or Minimum major version number to find.
minor Minimuro minor version number to find.
search Type of search to perform.
depth Number of Dame spaces lavers to search into.
A;l finds sll diff< rcnt items (dssses functions types etc.) of the specified name. ~either of the version numbers are specified all items with version numbers ~reater than or equal to numbers specified are rct~ed. Once the local view checl~s are complete then each mapped sdapter matching sy~tem should be checlced. If the depth parameter is I only the top level name sp~lce will be sea~hed It is the ~ ~ of the vie~v to decide whether an item from an adapter can appear in multiple locations in a view. The method VcrTopLevel:: InView c~n be cslled on the item to checlc if it is s}resdy in this view hierarchy.
r~ dt~
void E:numerate ( VTViewEnumFunc func void ~context VTClassTag type kVcrAll VTObjectSystem system = kVAnyObjectSystem -SUBSrlTUTE SHEEr (RULE 26) --g7--VTSearchType search = kVSearchAll) = o f unc Function to call for each item.
context Context i ' to pass inlo function.
type Tvpe of item to search for.
system Object system to do the search in.
search Type of search to perfo~n.
Enumerate . all items of the specirled type. If type is kVcrAll then all items are Onoe the lo~al vie v checks are complete then each mapped adapter matching ~ystem should be checked lf the depth parameter is I only the top level name space will be searched. For each item found, the . Iunction is called with the ~, context, and the itern itsel~ This should not _ - the items in any nested Ge spaces. It is the l~-r '''~'~ of the viev to decide whether an item from an adapter can appear in multiple locations in a view. The method VcrTopLevel:: InView can be called on the item to chec~
if it is already in this view hie~chy.
MappedAdapters VTAdapterRefList MappedAdapters ( ) = 0 MappedAdapters returns the list Or all adapter name spaces which have been mapped onto this vie v.
- Map bool_t Map (VcrToplevel ~item) = 0 item Itan to map into the Yiew.
Map maps a particular item in into the current view. The view should cache item so that it can be loolced up dunn~ searches and; Map applies to classes, functions, types, instances, ~ . and name spaces. A raurn or TRUE indicates that the mapping operation was ' ' Note that even if the return is ' ' the object may not be mapped directly in this name spsce. It may have been mapped into another place in this view tree.
Unmap void Unmap (VcrToplevel ~iteml - 0 item Item to unmap from the vie v.
Urlmap unmaps a particular item from the aurent vie~v. If item is mapped into this vie w it should be removed. Urlmap applies to classes, functions, types, instances, ~----r ' , and name spaces.
UnmapAll void UnmapAll (VTObjectSystem systeml ~ O
system Object system to unmap items for.
UnmapAll unmaps all items owned by system from the current view. Any items mapped in the view which ~ owned by system should be removed. Ur~apAll does not apply to name spaces only to classes, functions, types, instances, snd ~ ___r"
UnmapAllFromTree void UrlmapAllFl~ r..ee (VTObjectSystem system) = O

SUBSrlTUlE SHEEr (RULE 26) WO 96/08765 ~ PCT/CA9S/00S13 system Object svste~n to unmap items for.
UrmLapAll unmaps all items owned bv system from the current view and fram all contained views .. ~ v. Anv items mapped in the view which are o~ned bv system should be removed. UrmLapAllFromTree does not apply to name spaces only to classes, functions, types, instances~ and e -r ~
ClassCh~n~ed void ClassChanged( VClassData ~c15, shortnummeths shortnumprops short yy~S
short n~ n~ts ~hort-xcepts) = O
els Class which has chanFed.
nummeths Number of new methods in the class.
numprops Number of new p~perlies in the class.
numtypes Number of new types in the class.
numinsts Number of new instances in the class.
numexcepts Number of new ~ , in the class.
ClassChanged notifies the view that a class whLich it contains has chan~ed. It provides the view wlth the number of ne~v items which w~e added to the class. This allows the view to ge, ' ' tables to enable camplex searches through its contents.
AdapterAdded void AdapterAdded(VAdapterNameSpace ~n~pace) = O
nspace Adapter which was added.
The class reg~stry calls AdapterAdded far each top levd view when a new adapter has been instaUed. The view may map the adapter into its space in any way it chooses.
A~ t~ ~emoved ~ void AdapterRemoved(VAdapter~ -qpace ~n~pace) = O
nspace Adapter which was removed.
The class re~istry caUs AdapterRemoved far each top Ievel view when an adapt~ has been r~novod. The vie v may ~ 1~ store ' about where the adaptcrs items are in its hierardLy at this t~Le. Afkr this, the niew should um~Lp aU adapter name spaces and items bel~g~ng to the adaptcr.
Removed void Removed() - O
R~ ~ dis calle,d by the class regislJy an the top levd view to notify it that it has been r~noved fr~n the list of availabk views. The vie v can ~ store ' ~ about its hierarchy at this time. The view should then urlmap aU items and adapters and all sub views. After calling Removed the class registry will release its reference to the view which should cause tlLe view to be deleted.

SUBSm'lJTE SHEEr (RULE 26~

WO 96/08765 ~ ~ ~) n o 9 Jl PCTICA95/OOS13 _9~_ Class VClassRegistry Public subcl~cs of VPrimary VCla~ ~Regl ~~ try is a class which manages views and adapters. Adapters provide the interface between different objec~ systems and the views. Views provide a hiersrchv of name spaces which may be presented to the user. Views can be deftned by the us~r to group items into user defined; ~, Although any giveD class can appear only once in a view multiple views can exist at the same time. Any view can hsve any lavout of =es. The physical hierarchv of =es (classes inside narDe spaces etc. ) remains the same and views only reorda their hierarchv to suit their own needs. Views may be . as pasistent stonsge objects which store the virtual hiaarchv of name spaces and itams and reload it when later recreated. Ad~a views provide the physical hiaarchv of names.
Public Members VClas~Regi3try C- u~ ~ a VCla~Registry object.
-VCla~sRegis~try Destroys a Vclas~Registry objecL
Public Members TypeManager Returns the type managa used by this registry.
Overridable Public Members AddView Adds a ne~ top level view.
RemoveView Removes a view from the registry.
Views Returns alJ the vie~vs in the registry. .
AddAdapter Adds an object system adapter to the registry.
RemoveAdapter R~oves an object systan adapta fr~m the registrv.
Adapter~ Returns the list of installed object system adaptas.
VClassRegistly Constructor VCla~Regi~try(V~y~all~ager ~manager) r~anager Type manager to use for type: .
The VCla~Registry s ~ the iDternal data structures. The arguAnent specifies which type rnaDaga to use for type queries. The clsss registrv itself does not use the type rnana8~
~ directly. It is provided so that users of the class registry are able to determine ~ .
about the types contained in clsss, function ins~nce eYr rti~ and type " .~.
VClassRegistry De;.llu~;lor -VCla~Regi~try ( I
The VClas~Regi ~-try dest~uctor removes all views and removes 811 adapters. This will cause all class registry objects to be ~sh. unless they are still .~f~.
Type~n~
v .y~ ger A r~ ger() ~ O
TypeManager re~us the type rn~Anag~ associated with this class registry. The type msnag~ is used to n~ge ~ . ~ of data types.
AddView void AddView (WiewNameSpace ~view) SUBSTITUTE SHEE~ (RUI E 263 WO 96/08765 ~ 9 ~ _ PCT/CA95/00513 _ --100 -view View to add to the list.
AddView adds a new Qew to the list of top level views. The registr,Y will add a reference to the - view then notify it of all adapters attached to the registr,v.
RemoveView void RemoveView(Wic cpace ~view) view View to remove from the list.
RemoveView r~moves a view from the list of top level news. The registry will call Removed on the view and then rdease its reference to the view.
Views VTViewRefList Viewq() Viewq returns the list of all created top level views attached to the class registry. This list should not be modified.
AddAdapter void AddAdapter~VAdapterNameSpace ~adapter) adapter Adapter to add to the list.
AddAdapter adds an object s,vstem adapter to the list of supported adapt~s. As each adapter is added, the adapter is put on the end of the adapter list. -fhe order in which adapters are added to the class registry is important since the,v are queried in the ssme order. This will notifv each existing view that a new adapter has been added RemoveAdapter void R- veAdaptertVAdapterNameSpace ~adapter~
adapter Ad~terto remove from the list.
RemoveAdapter removes an object system adapter from the list of supported adspters.
Adspt~s can be removed in any ord~. This will notify each existing view that an adapter has been removed. -fh~ registry vill call Removedon the adspter and release its reference to the adspter.
Adapters VTAdapterR~fT~-qt Adapterstl Adapter~ returns tbe list of all installed object system adapters. This list should not be modi6ed.

SUBSTITUTE SHEE~r (RULE 26~

wo g6/08765 2 ~ ~ ~ o 9 ~ PCT/CAgS/00513 Implementation Classes These classes are. ' of the abstract classes defined in the E~posed Clusses section. These classes are directly ' '- and can be used to build up class registry entries in code. These classes may also be ! ' ' ' to provide special support for an objPct systP n adapter. It is up to the dPsignPr of an object systan adapter to decidc whethPr to subclass these classes or whether to subclass the classes defined in the E~posed Classes section.
Class VcrCodedFunction Public subclass of VFIln~tionna VcrCodedFunction is an . ' if VFunctionData which allows the object to be built up in simp1e C~ code bv addin8 , and P -~ one by one. This .' - stores the about the - ~ and ~. , b This class may be ' ' ' by othPr objPct svstems.
Public Members VcrCodedFunction C~ ~ ~ aVcrCodedFunctionobject.
AddArgument Adds an ar~nent to the function.
RemoveArgument RPmoves an argument from the function.
Yception Adds an exception which the function can thro~.
~ RemoveException Removes an excPption which the funcbon can throw.
~ot~ d Members PutType Sets the type of the function Protected Data Members bool t i tI aAMethod Specifies w11ether this is a method or not.
- void ~ it EntryPoint Stores the entry point of this function.
VTCallType it-~CallType Stores the calling _ . for this function.
VcrCodedFYne1ion Constructor VcrCodedFunction ( VAtomRef name, VTypeData ~re~ultType = 0, bool t i Method = TRUE;, VTU~ageCode ucode~ e 0, void ~entryPoint - 0, VTCallType calltype ~ kVCallTypeAn-~iC) name Name of tbe method.
resultType Return type of the metho~
isMethod Ihis object l-r- ~ a method.
ucodes Usage flags for the method (if any).
entryPoint Callable entry point of the metho~
calltype Calling ._ to use when ~alling the metho~
C~ , a function ~' ~ objecL If i~Method is tme tbe ~ adds a bidd~ first argument of type lcVTypeObjectPointer. ARer creation ~ can be added to tbe ~' p~ us~ng AddArgument. ARer tbe definition of the function is complete it um be sto~d in a class or name spacc SUBSrlTUTE SHEET (RU~E 26~

WO 9610876S ~ PCT/C~9S/OOS13 AddAl~,.. P.. ~
void AddArgument(VcrArgument ~arg) arg The argument to att to the function d ~
AddArgument atts an arglunent to the function ~ As each argument is attet, the argument is put on the end of the a~gument list. Arg~nents should never be attet to the function aRer it is ti ectly or intireetly installet in the class registry.
RemoveAl~,.. P."
void RemoveArgument(VcrArgument ~arg) arg The algument to ranove froln the function ~' p~
RemoveArgument ranoves an a~nent from the function ~ r' Ar~nents ean be rcmovet in any orter. Arg~nents should never be removed from the function aRer it is tirectly or intirectly installet in the class registry.
AddExcep~on void r~Yception(VExceptionData ~except) except The exception to att to the function d ~
Ye~ption atts an e~ption to the list of e r ' the function ean throw. To allow languages to aeeess the ~ "~ by name they should also be attet to ather a class or name space.
RemoveException void RemoveException(VExceptionData ~except) except The excepti~ to remove from the function d ~r- -RemoveException ~moves Jn exeeption from the list of e r-- that the function eantb~nv. r .,r can be removed in any order. F "~ should nevar be removed from the function aRer it is directly or indireetly installed in the class regislry.
PutType void PutType(VTypeData ~type) type Type of the functiolL
Sds the rdurn type of the function. This is intended to be ealled fiom ~ ' of VcrCodedEunction which need to set the type of the function aRer - ' ~ of the base elass. The type of the funetion should not be ehanged after it has first been retrieve~
Class VcrCodedProp Public ,.,l,c~cs of VPropDa~a VcrCodedPropis an ~ , ' of VPropData which ean be used direetly from C++ so that a subclass of VPropData does not need to be defined. VcrCodedProp stores the aeeessor methods inside itself. This class is designed to allow ~
Public Members VcrCodedProp C~ , avpropDataobject.

SUBSTITUTE SHEEr (RULE 26~

WO 96/08765 F 2 2 0 n Q 9 ~ PCT/CA9S/OOS13 Protected Members PutType Sets the type of the function.
Protected Members PutGetMethod Sets the ~get" method of the property.
PutSetMethod Sets the ~set~ metbod of the property.
VcrCodedProp Constructor VcrCodedProp(VAtomRef name, VTypeData ~resultType ~ O, VTUsageCode ucodes = O, VFunctionData ~getMethod = O, VFunctionData ~setMethod = ~?
name Name of the p~p~.
resultType The type of the property.
ucodes Usage flags for the proper~y (if anv).
getMethod n p~ ofthe ~get" method.
setMethod n p~ of the ~set~ method.
Cc ~ ~ q a p~p~ly d ~ The names of the accessor methods should be the name of the property preceded with either "Get~ or "Set~. This naming .~ allows properties to be accessed ~ across multiple class registlv enabled ~, -, , 1 1, , PutType void PutType(VTypeData ~type) type Type of the prvpaty.
Sets the type of the pr~perty. This is intellded to be called from ' ' of VcrCodedProp wbich need to set the type of the pr~ after ' of the base class. The type of the p~pa~y should not be changed afler it has first been retrie~e~
PutGetMethod void PutGetMethod(VFunctionData ~getMethod) getMethod D--- p~ of the ~get~ method.
Cbanges the ~get~ method of the p~. No~mallv this should only be called from a suoclass which needs to set the data after cr~tion.
PutSetMethod void PutSetMethod(VFunctionData ~etMethod) setMethod ~ of the ~set~ method.
Changes tbe ~set" method of the propaty. Nonnally this should only be called from a subclass wbich needs to set tbe dats afler creati~.
Class VcrCodedClass Public sub~l~cs of VClassData SUBSmUTE SHEEr (RULE 26 WO 96/08765 ~ ~ ~ PCTtCA9S/OOSl3 VcrCodedCl,scs is an i ' of VClassData which is used to define classes directl~ ~om C~ code without the need to subcl ss vcl-~cn~~s The instance stores lists of methods, pr~paties, t pes, instances, and -r " as thev a re added This ct~ss is designed lo be ~ ' ' ' if so desired Public Members VcrCodedClass C~ I aVcrCodedClass object Public Members AddMethod ~dds a method to the ctass ~'---ip' R~ , et~ethOd Removes a method from the clsss ~' - --ip' AddProperty Adds a property to the ctass d~, RemoveProperty Removes a prop~ty from the ctass d~ 'r ~i Ad~ e Adds a type to the ctass ~' p~
P~ Removes a type f~n the class d 'r~
AddInstance Adds an instance to the ctass ~ p~
RemoveInstance Removes an instance from the clsss ~ - r"
Yception Adds an exception to the class d~ 'r ' ' RemoveException Removes an exception from the class ~ ip' P~otect~d Members PutBaseCla s Sets the b~se class of tlus class PutBaseCla ses Sets the hst of bsse classes of this ch ss PutConstructor Sets the ~ function PutDuplicator Sets the copy _ , function PutDe tructor Sets the destructor metho~
PutAcguireMethod Sets the acquire method PutRelea eMethod Sets the release method MyMethods Returns the list of methods defines in tbis class MyPropertie~ Ret~ns the list of pr~p~ties defines in this class M~ ~ ~es Returns the list of types defines in this clsss MyInstances Returns the list of instances defines in this class MyExceptions Returns the list of , defines in this class ~hct ,d Data Me~..bç~ ~
VTVersion itsMajor Msjor version number of the cl~ss VTVersion itsMinor Minor version nu~nber of the class VTCastList itsCastToBasesList Iist of functions wbich c~st to the given base classes VTSaf eCas tLi t it ~Cas tFromBasesLi ~It List of functions which csst from the given base cl~wes VcrCodedClass Co~lluclol~
VcrCodedC'l a~s ( VAtomRef name, vrla~nata ~ e~ la~- - O, VFunctionData ~constructor e 0, VFunctionData ~duplicator e 0, VFunctionData ~destructor e 0, VFunctionData ~acguire e 0, VEunctionData ~release - 0, VT~sageCode ucode ~ 0, VTVersion major ~ 0, VTVersion minor = 0 ) SUBSTITIJTE SHEEr (RULE 26~

W O 96108765 ~ 2 0 0 0 9 ~ PCT/CA9S100513 VcrCodedClass( VAtomRef name VTClassLlst ba~eClasses ~ VTCastList ca.~tToBases VTSafeCastList castFromBa~es VFunctionData ~constructor = O
VFunctionData ~duplicator = O
VFunctionData ~destructor = O
VFunctionData facquire = O
VFunctionData ~release = O
VTU ageCode ucode = O
VTVersion major = O
VTVer ion minor = O) name Name of the class.
baseClass The base class (or NULL) for this singly inherited class.
baseClasses The list of base classes for this multiply inherited class.
castToBases The list of functions used to cast to each base class.
castFromBases The list of functions used to cast from each base class.
constructor D--- p . of the class ~tll .
duplicator Dff~pti~ oftheclasscopv destructor D ~, 'r ~i of the class destructor (must be a method).
acquire D~-- p of the method used to add a reference to an instance (must be 8 method).
release D " of the method used to remove a reference to an instance of the class (must be a method).
usage Usaye codes for the class.
major Major vasion number of the class.
minor Minor version nu nber of the class.
C~ a d ~1 of a class. The class may be a base class, singly inherited, or multiply inherited. To construct a base class the fi~t overload of the _ ~ . should be used with NUI.L as the base cl~lss.
constructor is the pnnwry _ ~ for the class. constructor may be used, for instance, by an l~r- builder to construct an instance of the object. For a hnguage ~ . if con~tructor is not spocified then an instance cannot be created but must be ~ ' 3 by some oth~ means. An instance could be returned by a function for example.
It sho~d be noted that these methods (constructor copy destructor acquire release) do not necessarily need to be ,' ' by the object itself, but may be c . functions designed to ease the ~ into the class regislry. con tructor and eopy may have any ~ but destructor acquire and release must ha~e no ~r, or all the ,, must have default values.
castToBa~es and castFromBases must either be zon length or ha~e the same number of entries as tbere are base classes. This is a List of fimction pointers. Eac'h function in castToBases takes an object instance as an argument and returns the c~,.. . ' _ pointer for the ins~nce when cast to that base clsss. Each function in castFromBases takes an object instance and a boolelm (s~pecifying whether the cast is to be a type safe cast) as r" and returns the c ~ pointer for the instance when cast from that base class to this class. If any of the entries are O th0 it is assumed tbat the object, when cast to/from the base class, raains the same pointer. This list is used by CastToDirectBase and CastFromDirectBa e. It is needed -r ,i~ ~Iy when C~ multiple ' classes are used. If VcrCodedCla is ' by an object system which does not need to do these casts, an empty list can be passed into the _ lC' SUBSTITUTE SHEET (RULE 26) WO 9610M65 ~ PCIIC~9S/OOS13 AddMe~od void Add~fethod (VFunctionData ~method) method The method to add to the class d ',~ti Add~fethod adds a method to the class ~ r' methots can be sdded for normsl methods while otha VFuncti onData objects can be added to suppo~t the concept of static methods of a class. Methods mav be added after the class has been installed or ..f~ ~ in the class registry.
RemoveMethod void R . ~fethod (VFunctionData ~method) method The method to ramove from the class ~ -ip~;
R .e~lethod re,moves a method from the class ~' --ip~' Methods should neva be removed f om the class ~ afta it is directly or indirectly instsUed in the class reglstry.
Note that ~ to r~move a method which is installed in a . ' of this chss W2U not produce the desired effect. The method must be 2~2noved fi~m the chss inwhich it was defined. The effect of removing a method from a subclass can be producod by addi2~ the sa2ne method ~ ;-- to a subclass' class d ~ --- but vith the usage flag kW sageHidden.
Add~lulJel ly void AddProperty (VPropData ~prop) prop The 2,x~paty to sdd to the clsss d -- '?~' AddProperty sdds a property to the class d ',~' I'ropcrties may be sdded sfter the class has becn installed or .~:L ' in the class regisb~
Remove~tu~C~lr void RemoveProperty (VPropData ~prop) prop The p~paty to remove from the class d --iLr' Re~oveProperty 2~moves a pr~perty from the class :' ', ' Prop~ties should never be ranoved from thc c ass d i,~' s2ta it is directly or iud~ealv instslled in the class registry.
Note thst a' .-' _ to 2emove a propa~y which is instsUed in a . .' of this class~d - r" wiu not 2xoduce the desired effect. The 2.~ropcrty must be removed from the clsss in which it wss define~ The effect of removing a 2n~pat,v from a subc~ss can be 2noduced by sdding the s~ne prop~ty d- 'p~' to the subclsss' clsss d ', ' but with the ussge nag kWsag.~Ti t~t~t~n AddType void Add~ypetV'rypeData ~type) type The type to sdd to the class ~' ---ipi i~dd. ~.~e sdds a ~?e to the c ass ~ Types may be sdded sfter the class has been installed or ..~ ~ in the clsss registry. Note thst in a languaae this type will only be ~. . '' ' '- in the context of sn object of this 2.~ar~icular clsss. To def2ne a tyoe for gene2al usage sdd it to a nsme s,oace instead SUBSTITUIE SHEET tRU~E 26) WO 96/08765 ~ 2 2 o o o 9 cl PCT/CA9SIOOS13 RemoveType void RemoveType(VTypeData ~type) type The type to remove from the class d p~
R ~ eIy~e removes a type f~n the class d~ ti Types should never be removed from the class d ?~- after it is directly or indirectly installed iD the class registrv.
Ad-l~n~t~nce void AddInstancelVInqtanceData ~in3t) inst The instance to add to the class d -AddIn3tance adds a named instance to the class ~' - p~ Note that this will typically only be used for named constants. InstaDces may be added after the class has been installed or .,_L _ ~ in the class registry. Note that in a language this instance will onlv be 1"' ' ' in the context of an object of this particular class. To definc an instance for general usage add it to a name space instead.
Removeln~t~nce void RemoveIn~tance(VIn~tanceData ~inst) inst The instance to remove from the class d p~
RemoveIn~tance removes a named instance from the class ~--- p~ ~stanoes should never be removed from the class d---ip~ afler it is directly or indirecth~ installed in the class registry.
AdllF.xception void A~FYception(VExceptionData ~except) except The exception to add to the class ~
AddException adds an exception to the class d ~ :r ~ ~ r - "~ mav be added after the class has been installed or .. ~ ~ in the class regis~y. Note that in a language this exception will onlv be . . 'i ~ '- in the context of an object of this particular class. To dehne an exceptioD
for general usage add it to a name space instead.
RemoveException void RemoveException(VExceptionData ~except) except The exccption to remove from the class d p~
RemoveException ranoves an exception from the class d ~~ r ~ should never be removed from the cll~ss ~lL---r afler it is directly or indirectly installed in the class registry.
PutBaseClass void PutBa~ecla~(v~la~Data ~ba el base The base class of this class.
PutBa~eCla~ sets the base class for the described class. If the class is multiply inheited PutBa~eCla~e~ should be used ins~ad. This method can be used by s ~ ' to store ad~ 'Iy generated base class.

SUBSTITUTE SHEE~ (RULE 26~

WO 96108765 ~ Q ~ PCT/CA95100S13 --10~
PutBaseClasses void PutBa~eCla~s(VTCla~sList ba~e~) bases The base classes of this elass.
PutE~aseCla~es sets the list of base classes for the described clsss. This method can be used b~y ' ' to store a ~ "~, g0erated base elasses.
PutConstructor void PutCon~tructor(VFunctionData ~constructor) constructor The c for the elsss.
PutCon~tructor sets the _ I for the described elass. This c I is not identicsl to the C~: ~ for an objeet. The elass registry defined _ , is 1~ r '~ ~ for alloeating the objeet and it must return the new object. The elass registry d~ n-~ for the : b, ~i~ hsve a generie object return type (type code kVTypeObjectPointer). The VFunetiorlData stored using this method does not have a hidden f~rst argument for the objeet instance. Thus, this VE'unctionData should not be ' ~I to be a method.
PutDuplicator void PutDuplicator(VFunctionData ~duplicator) duplicator The copy; , for the elass.
PutDuplicator sets the eopy; ~ for the described elass. This ~ ~ - is not identicaJ to the C~ copy c I - for sn object. The elass registry defined copy , is 1~ r '~ for allocating the objeet and it must return the new duplieate objeet. The elass relpstry ~'-~ rp' for the copy - ~ will have a generie objeet return type (type code kVTypeObjectPointer). The VFunctionData stored using this method has a hidden first llrg~nent for the objeet instance whieh is being copied Thus, this VFunctionData ean be - ' i to be a meth~L
PUtDeStrl;tCtor void PutDe~tructor(VFunctionData ~de~tructorl destructor The_ ~ fortheelass.
PutDe3tructor set the desbuctor for the described elass. This method must have no r ' or ha~re defsult values for all r _ This destruetor method is not identicsl to the C~ d I in thst this one is r '~~ for ~ ' , the setual free of the memory sllocated for the objeet instanee. de tructor must be a method.
PutAcquireMethod void PutAcquireMethod(VFunctionData ~acquirel acquire The ~cquire methed for the el~ss.
PutAcquireMethod sets the method used to add a referenee to an instanee of the elass. This method must hs~re no ~ ~ or all ~ L must ha~e default values. acquire must be a method. lf an objeet system does not inherently support reference eounting the elass registry esn pro~lide support for instance bssed reference counting using utilitv classes.

SUBSTITUTE SHEE~ (RULE 26~

WO 96/08765 ~ 2 0 n o 9 1I PCT/CA9Sl00513 --1 0 9 ~
PutReleaseMethod void PutReleaqeMethod(VFunctior~ata ~release) release The release method for the class.
PutReleaseMethod sets the method used to remove a reference to an instance of the class.
This mcthod must have no ~ ,, or all ~ _ must have default values. releaae must be a method. If an object svstem does not inherently suppOn reference counting the class re~istry can prnvide suppOn for instance based refcrence counting using utility classes.
MyMethods VTFunctionList MyMethod3(~

MyMethodq returns the list of methods defined in this described class. This onlv returns the list of methods which have been added using AddMethod. It does not return any methods of the super classes of this describod class. This will typically be used to help a subclass of VcrCodedClass determine which method s~ p~ have alreadv been d! "v generated for this class MyF't~ ies VTPropList MyProperties() MyProperties returns the list of propenies defined in this described class. This onlv returns the list of propenies which have becn added using AddProperty. It does not return arly properties of the super classes of this described class. This ~vill typicallv be used to help a subclass of VcrCod-~dC1aqs determine which pr~ have already boen 'ly generated for this class MyTypes VTTypeLiat My~y~a() MyTypea returns the list of types definod in tbis describod class. This only returns the list of types which have been addod using AddType. It does not return any types of the super classes of this described class. This will typically be used to help a subclass of VcrCodedClacs determine which type ~ have alresdy been ~, ",y generated for this class MyTn~nces VTInatanceList MyInatancea~) MyIn~tance~ returns the list of i~lstances definod in this described class. This only remrns the list of instances which have been addcd using AddInatance. It does not return any instances of the super classes of tbis described chss. This will typically be used to help a subclass of VcrCode~ aaa determine which instance d~ r have already boen genorated for this class MyExcephons VTExceptionList MyE~ceptions() SUBSTITUTE SHEE~ (RULE 26~

WO 96/08765 ~ PCTICA9S/00513 MyException_ retums the list of - - -r~ defined in this described clsss. This only retu ns the list of ~ which hsve been sdded usin~ Yception. It does not return sny of the super classcs of this described clsss. This will typically be used to help a subclsss of VcrCo~iedClAqs detcrmine which exception d--- pi have alresdy been d~ genc~ated for this class ~'--- p~
Class VcrSimpleAdapter Public s~bcl~cs of VAd~,NameSpace VcrSimpleAdapteris sn i . ' of VAdapterNameSpace which csn be used ss the bsse . ' for object system adspt~s. It provides support dl methods of VAdapterNameSpace.
Object svstems may subclsss this snd provide dvnsmic lookup in the different methods but use the csching suppnt provided by VcrSimpleAdapter. Eitha VAdapterNameSpace or VcrSimpleAdaptercan be ' ' ~ whcn crcating nsme spsccs for diffcrcnt object systcms.
This providcs a simple sdapter stmcture which csn be used directlv through its Inqtall, Remove methods or which can bc ' ' ' by an object system sdspter to provide sdditionsl ~ ' ~.v.
Ovenidable Public Members Install ~ ls an Itcm in the adapter.
Remove Removes an itcm from the adspter.
Ovemdable ~lot~cled Members S~hSpaces Rctusns the list of sub spsccs ~ithin this one.
Install void In3tall(VcrToplevel *item) it~n Ite~n to install in the namc spacc.
Install insb~sa ps~io~ar item into this ~~c name spsce. Install only spplia to classes, functions, types, instances, snd s "~ Once an object has been crested it csn be installed in the code sdspter so thst it msy be visible to the diffcrent ~iews.
Remove void Remove~VcrToplevel ~iteml item Item to remove fr~nn the Dsme space.
Remove r~novcs a psrticular item f~nn the nsme space. If itemis mspped into sny views it will be ~ f~n than all. Remove spplies to code name spsccs, clssscs, functions, types, instsnca, snd ~ .
SubSpaces VTAdapterList S~hSFace~(VTSearchType stype) s type Type of scarch to perform sl~hspzc ~ retricves the list of sdspter name spaces which are contained within this name spsce. This mcthod is called by bsse class , ' of other methods to sid in ~ r ~
rdve searches (i.e. scarches uith a depth other thaD 1). S ' ' C8D ~c .' this method to providc suppost for dyD~nic lookup of ncsted name spaces.

SUBSmLI~ SHEE'r (RULE 26~

WO 96/OM65 ~ ~ () ~ ~ 9 'I PCTICA9S/OOS13 Class VcrCodeAdapter Public sobrl~cc of VcrSimpleAdapter VcrCodeAdapteris an , ' of VcrSimpleAdapter which stores items created directly in C~ code in cache tables inside itseK This provides a simple adapter structure which can be used directly through its In~tall,Remove, and CreateSubSpace methods. On top of the ~ ' ~ provided by V~ dapter this class prondes support for end user creati~ of nested name spaces. Object system adapters should subclass VcrSimpleAdapter instead since users of the adapter are not typically allo~ved to created nested name spaces in the adapter (without support from the exposure mixin).
Public Members CreateS~hSpace Creates a nested name space inside this ~e.
CreateSubSpace VTAdapterRef CreateSubSpace(VAtomRef name) name Name of ne~v na~ne space to create.
CreateSubSpacecTeates a new adapter name space and installs it in the cu~Tent name space.
~ If a name space of the speciGed name alreadv exists it should be returned instead.
~ Class VcrSimpleView Public ~vl~ of WiewNameSpace VcrSimpleView is an i .' ~ of W iewNameSpace which prondes the base level of r ' ~ ~ needed to cache items from the adapters. It provides a simple policy for mapping adapter name spaces into itsel~ Each adapter shares the top levd Ge space. As top level name spaces inside adapters are found, they are mapped onto the top level name space. ~side these mapped name spaces, the direc~y reprcsent the hierarchy defined in the adapters i' '~. There is no built in support for ~ This cbss may be ' ' ~ to provide support for r - and to provide a different nuppug policy. The n~pp~g policy can be changed by ~ AdapterAdded and MapAdapter.
r~ support can be providod by o . " ~ R~ .~d and AdapterRemoved.
~tecl~d Membas In~tall ~$~s an item in the ~iew.
Remove Ranoves an item f~nn the vie~,v.
CanMap R~rns whetha the adapter item can be mapped.
Ov~Ti~lqble ~l~tt.;led Members CreateSl~hSpace Creates 1~ nested name space inside ~is onc S~hSpace~ Returns the list of sub spaces within this one.

void Install(Vcr~oplevel ~item) item Item to install in the name space.
In~tall installs a particular item into this ~iew name space. Install applies to classes, functions, types, instances, , adapters, and views. Once an object has been retrieved from an adapter it can be installed in the view so that il may be visible to users of the class registry. In~tall installs the item directly in this view. This method performs all necessalv reference counting ., SUBSrlTUTE SHEE~ (RULE 26~

WO 96/08765 ~ 3 t PCT/CA9S/00513 Remove void Remove (VcrTop1eve1 ~item) item Item to remove from the name space.
Remove ramoves a p~rticular item from the name space. Remove applies to views, adaptas, classes. funetions, types, instanees, and ~ ~ ~ This method paforms all necess~rv reference counting t'r CanMap bool t CanMap (VcrTop1eve1 ~ item item Item to check.
Car~Map returns whetha item can be mapped into this view. If the return of this method is FALSE then no other view method should return the item. This is called internallv to check whetha an item can be returned from the view methods. The default . ' retu~ns the resultsofcallin~item->InView(thia). Thismethodeanbe.. .- :~'in ' ' to provide support for mappirlg items into multipk locations in the vicw.
CreateSubSpace VTViewRef CreateSubSpaee (VAtomRef name) name Name of ne v name space to create.
CreateSubSpaee creates a new view name space and installs it in the currant name space. If a name space of the specified name already exists it should be returned instead. This method should be o._,idd. in ' ' so that the correct elass ot nested name space can be SubSpaces VTViewList Sl~hSpaces (VTSearchType stype) stype Type of seareh to perfonn ~ S~hSpae~ retneves the list of view name spaces which are eontained within this name space.
This method ean be _._ '' in ' ' to pr~ride support for retrievin~ F '~ stored view r Class VcrFlatView Public ~JI,cl-cs of VcrSimpleView VcrF1atView is an . ' of WiewNameSpaee whieh provides a ~t name space model. As each adap~er name space is found, it is mapped onto the top level nalne space of the view. All items ean be found direetly in the top level name spsce of the view. This elass ean be used by l~mguages sueh as Basie whieh have no way of dealing with the conc~t of multiple name ~ff. This elass shoult not be ~ ' ' To provide different . ' of nat name spaces, VerSimpleView should iDsteat be s ' ' ' instea~

SUBSTITUlE SHEEr (RULE 26~

wO g610M65 ~ 2 0 0 O 9 1 PCT/C~95/00S13 Type Management Classes Defining Complex Types If the set of possible ty,oes was limited to the r ' ' ' types the class registry would only be useful to describc a srnall subset of all defined classes. However, the se~ of possible types is not static. New types can be w~ ' to A~scribe any compleY data type.
r. types and wmplex t,vpes such as structures, uruons, and enurns can be described using the ~ ' ofVTypeData. D - ' ' of types can be nested to create arbitrarily wmplex data types.
The type system is not intended to map every possible C~ type to a type d~ - ;14'~ It is intended to be able to describe an,v standard object system type. The set of types which the type system can _escribe includes all t,~ s which can be described within CORBA II)L and CORBA TypeCocle~. The set of d '' ' ' t,~pes does not include objects. Object A~ ti..-._ are giveQ
by the other class rq~stry VClassDatainstaQces.
Types are described by ~ a hierarch,v of t,~pe ~' Y ~ 'p~' objects. Once a type has been built it can be used iQ the class registry directlv. The type classes provi_e facilities for cas~ing an instaQce of one tvpe to that of another type. Types wiich are similar iQ structure can be cast to each oth~. Unlike C and C~, the class registry type system will cast structures ~ hich have similar f eld ~ p~ to each otha even if the data types of tQe fields diff~. This f ' ' ' ~ is used to provide object svstelQ brid~in~
The class r~istry function and method callin~ support wde (VcrCall and VcrCompleteCall) employ the type system to cast , and return values to the ~.r ~r ' ' typcS. While the function caLliQg support wde does type checkin~ to make sure that type ~ O ' and return types can be cast wrre-,tly, it is the - --r '' '''~ of tQe user to do strict type checl~ing before calling before calling these functiorls.
Each type object can have ~ ' ' with it a type code. These type codes uniquely describe a type inside a mnning instance of the class reOistry. The type codes can be used for fast type , ' The type m~Ber is ~ for managing the type codes. The type manager gellerates a unique type wde for a type if an identical type d--- 'p~' is not already in its database. If an identical type already exisls, both types will be given the same type wde. Thus any instances which have thc s~AAnc type wde are identical.
This does nof mean that twû instances with different type .~,odes are not the same in layout and structure.
Different complex types may have the sAme layout of fields and subtypes but, if the names of the fields differ, the twû types will be given different type wdes.
Ex.~,ept for the 1~ ~ ' types, type wdes ar not r Every different process space will have a different type wde for the described types. Howe~er, this is not usually a problem since type codes are only used in type _ , ' There is a set of available persistcnt type codes. Tb~e are allocated on an as nec_ed basis by Visual Edge. Pe~ent type wdes will anly be assigned to r ~ ~ ~ type d 'pti The type manager is ---r ~' for traclciDg all persistent types codes. A persistent type can always be loolced up in the type m mager to find its ~ '. ' objecL
Since types are described by objects, these object ~nay have mixiDs. Mi~ns on types caD be used to provide a_ditional ' ~ ' about aA type to a !~ ' For instance, a type naAned "color" may be identical to un~igned long except that it has rnwn support for bringing up a -r ' '' ' color editor.
Predefined Types The set of ~ types ~,overs the ' c , of C~ r ~ ~ typcs as wdl as a number of simple composite types such as string and generic object pointer.

SUBSTITUTE SHEEr (RULE 26~
.

WO 96/08765 ~ PCT/CA9S/OOS13 Flln~..r.~ Types The set of r ~ ' I types snd other ~ ' types have d---ip' stored in the type rnanager.
These type ~'---ip~ can be found by querying the type rnsnager given the type code. The currently defined set of type codes is as follows:
kVTypeVoid kVTypeByte kvTypesiqn~chA r kvTypeunsi~ne~lcha r kVTypeChar kVTypeSiqn~hort kVTypeUnsignedShort kVTypeShort kVTypeSignedInt kVTypeUnJignedInt kVTypeInt kvTypesiqne~T~nnq kVTypeUn~i~ne~T.n~q kVTypeLong kVTypeFloat kVTypeDouble kVTypeLongDouble Other Pre~efin~d Types kVTypeVoidPointer Geneic pointer.
kVTypeObjectPointer Generic object pointer.
kVTypeFunctionPointer Geleic function poirlter.
The following tvpes differ fro~n other described complex types in that their type codes sre persistent scross multiple sessions.
kVTypeSignedString Signed string.
kVTypeUnsignedString Unsigned string.
kVTypeString Sting of default sign for nstive platform.
kVTypeBString Bssic IsQ~e string.
kVTypeVariant or F2.ov~RIANT~
Class VTypeData Public s~lbçl~cs of VcrToplevel VTypeData is the base class for all type ~ r'' cbsses. It provides virtual methods for type - . cssting,creatiorl, snd ' ~ ~
Protected Members P-lLI~ aqer Sets the type rnanag~ which owns this instance.
PutBaseType Sds the type that tbis one is bssod on.
GetActualIn~tance Gettherealtypeandpointertoaninstanceofatype.
Public Members saJeType Returns the base type of this type.
TypeManaqer R~ns the type ma~ag~ r ~ ~ ' ' with this object.
I tJCl asJ R~rns the subclass of VlypeData which this is.
PutObjectSyJtem Sets the object s,vstan which . , ~ this type Overridable Public Members ConcreteType Rdu~s the physic~ . ' of this type.
TypeCode Retu~ns the type code of this type.
Identical D~' whether the specified type is identical to this type.

SUBSTITUT~E SHEET (RULE 26) wo 96,08765 ~ ~ ~ ~ 9 ~ PCT/CA9S/OOSl3 SameLayoutAs ~ - whether the specified type has the same layout as this type (al&ough it may have a diff~ent name) CanAlway~Ca t n whether the specified type can alwavs be cast to &is t\lpe.
CanSometime~Cast n -whdher&especifiedtype mav be cast to this type.
Alignment Returns &e aliE~nent required by &is type.
SizeOf Ret~ns the size of an instance of &e type.
Construct C- ~t~ a new instance of &is type which is a correctlv cast copy of the specified type.
Ca~t Cast an instance of &e specified type to this type.
E~mpty E~nptv an instsnce of &is type.
Discard Discard an instJnce of &is type.
Protected Data Members VTObjectSystem itsObjectSy3tem Theobjectsystemwhich ~ thistype d ~
Type Definitions VTTypeRefList VrRefList of VTypeData objects.
VTTypeRef VrReferencetoaVTypeData object.
PutBaseType void PutBaseType(V~ypeData ~base) base Type that this is based on.
PutBa eTypesets &e type on which &is derived type is based. For instance, if this type is a pointer to unsigned short, BaseType should reO~rn a type object ror kVTypeUnsigne~i~hort. If this type is not directly derived from ano&~ type then it should return NULL. For instance &is would be &e case for a structure definition. An instance of VcrAny should return &e type &at it actually is when placed in memory (i.e. both a CORBA
anyand an OLE 2.0 VARIANT would be instances of structures wi& particular field layout.
This me&od can be called by ' ' to store &e base type if it is not l~nown on creation.
PutType~f~n~g~r void PuL,y~-5~ ager(VTypeManager ~manager) manager Type m~msger &at owns this type.
PuLI~5~ ager sets rehnns &e ~ ~S~ager instance w~ich manages &is type This is used by Sl' ' to store &e type menager in &e base class if it is not l~nown Rer ~:ati~nL
GetAc~slT~ ce void GetActualIn.~tance( const VcrDataRef &instance VcrDataRef. &final) SUBSTITUTE SHEEr (RULE 26~

W0 96/08765 ~ PCI/C~95/OOSl3 instance Instsnce to convert. '~
final (Return) Instance after ~ ' -' GetActua1Inqtance takes an instance of a type an resolves it as much as possible. That is, this will resolve VcrAlia-- and VcrAnyt~pesto find the final result. If the instance is a VcrAny then the TypeOf and Value members of VcrAny~i~ be stored in final. ~udsnces of VcrAlia~ will just have the type resolved using Ba~eType of the alias. This method performs these ~r ~- until all aliases and sny's have bPen resolved. This method is used by to help perfonn casting.
BaseType VTypeData *Ba eType() Ba~eTypeleturns the type on which this derived n,pe is based. For instance, if this type is a pointer to unsigned sho~, Ba~eType should return a type object for kVTypeUn~ign~Chort. If this nype is not directlv derived from another type then it should return NULL. For instance this would be the case for a structure ~' ' ' Type~ns~
~y~ ager ~Typ~Manager~
Typ~Manager returns the VTypeManager ins~snce which manages this type ~ -ip~' ItsClass VCla~ ~ItsCla~3(h It Claq~ retwns the type of this instance. This is used to perform run time type ~ r of VTypeData The methods of VCla csn be used to identify which of the ' ' of VTypeData this is. ItaCla~is ca~ed in type . ~utines to gather j r " about the type bemg converted.
PutObjectSystem void PutObjectSy~tem(VTObjectSy tem 3y tem) system Object system which owns the nype.
PutObjectSy~te~ sets the object system which owns this type. This method should only be c~lled by object systems right after creation of the type.
ConcreteType VTypeData ~Concrete~ype~) ConcreteType retu ns the type which is the physical layout of this type. For instance, a type which is a CORBA sequ~ce has a concrete type which is a structure ~ three dcme~ts.
All ~w which are ;' '-w concrete should rcturn NULL fn~m lhis met~L The default retu~Ds NULL.
TypeCode VTTypeCode TypeCode() TypeCodere~ns the type code for this n,~e. The type code can be used to compsre two different typw to determine their equality. The ~pe manager is used to detamine the '' ''~ of typ~w. On the initial call to TypeCode, the type msnager is called to find a VTTypeCode for this type. A~er the initial call the result is stored in the type.

SU8SrlTUTE SHEEr (RULE 26~

wo 96,08765 2 2 0 0 0 9 ~ PCT/CA9S/OOSl3 l~n~5~1 bool_t Identical(VTypeData *type) type Type to compare to.
Identical d whether the specified ~pe is identical to the current type. This should be return true if the type is an exact duplicate: all subtypes. sub fields, and names must match.
Help ' ' ' should not be compared. The type manager calls this method to determine if two types csn be given the sa ne type code. The base class ' . ' checks that the two types are of the same subclass of VTypeData. A deri~ed type should make sure that c ' . ' ' ' in type !~ r "' do not cause the system to hang when _ . ' e two tvpes.
!~m~l ~youtAs bool t SameLayoutAs(VTypeData ~type~ = O
type Type to compare to.
SameLayoutA~ !~ ' whether the specified type is identical in lavout to the current type.
This should return true if all subtypes, sub fields. and offsets match. Names and help ~ - ' should not be compared. This mdhod is called to determine casting p~
CanAlwaysCast bool_t CanAlwaysCa~t(VTypeData ~type) = O
type Type to compare to.
CanAlway3Ca~t~'' wbether type can be cast to this t~pe in all situations ~ithout loss of ' ' " For instance a hort can alwavs be cast to a long, but onlv certaininst~es orlong can be cast to hort. This ~ould return t~e only for horttolong.
CanS~ ;,Cast bool t CanSometime Ca t(VTypeData ~type) = O
type Type to complue to.
CanSometime Ca~t .~ wh~her type can be cast to this type in some or all situations without loss of ' ' ' For mstance a -~hort can always be cast to a long, but only certain instances of long can be cast to ~hort. This would return tTue for casting either horttolong or longto hort.

long Alignment() ~ O
Alignment~eturns the ~t ~quired for instances of this type. The alig~nent specified in nu nber of bytes. For aulmple an eight byte double might be able to be aligned on four byte in which case tbis method would return four. The lowest possible value is one.
SizeOf long SizeOf(void ~in tance) ~ 0 instance Pointer to i~ce to use for d- ' ' _ size.
SizeOf retur,ns the size of a pluticular inslance of the type in b,vtes. If the instance pointer is NULL then SizeOf should ~ the size of all instances of the type if the size is fixed. If the size of instances is vanable SizeOf should return O or ne~ative.

SUBSTITUIE SHEET (RULE 26~

WO 96/08 76~ PCTICA9S/OOS13 Construct long Construct( const VcrDataRef &original - void ~instance) = O
original Type of and pointer to ori~inal object to copy from.
instance (Return) new instance of this type.
Construct builds a new instsnce of tbis t,pe bv cas~ing the input object to this type.
Construct should allocate a buff~ for the new returned object. Thc return ~ralue should be the size of the new instsnce. If the original instance could not be cast to this type or memorv could not be sllocated Con~truct should return 0.
Cast long Ca~t( const VcrDataRef ioriginal void ~instance) = O
original Type of and pointer to original object to copy from.
instance Pointer to ~vhere to store the inst~nce.
Cast builds a new instance of this t,~pe b,v castin~ tbe input object to this type. Cast should not allocate a butrer for the new type instance but should instead use the supplied buffer ~hich is ~ to be lar~e enou~h to fit the type. The return value should be the size of the ne~
instsnce. If the origiDal instance could not be cast to this type or memony could ~t be allocsted Ca~t should return 0. The instance butrer passed into this routine ma,v contain ~arbage snd as such should be fully o.~
Empty void Empty(void ~in~tance) = O
instance Instance of type to be emptied.
E~pty Qnpties out the contents of an ins~mce of the tvpe. This sbauld free all memory allocsted witbin the instsnce but it should not free Ihe instance itsdf.
Discard void Di card(void ~instance) O
instance Instsnce of type to be emptied.
Di card Qnpties out the contents of sn instsnce of this type. This sbculd free all memo~y sllocsted within the instsnce snd should free the memory used to store the instance itself.
Class VcrF--n~l~mental Public ,~ll,cl~c~ of V~ypeData VCrE~ tal defines a ~ ' ' type. 'Ihis class is -' ' ' intanally to p~ovide the . ' ' of all the f ' ' types. UsQrs should not normally need to subclass this class unless they sre pm~/iding snother ~ ' ~ ' type.
Public Members VCrElln~ tal C- , sVcrE--n~l tal objecL

- SUBSTITUTE SHEET (RULE 26~

WO 96/08765 ~ ~ O (~ O 9 1 PCT/CA9S/00S13 vcrF~ ment~l COIl~l~uClol VerF~n~i -tal ( VTypeManager ~manager, VAtomRef name, VTTypeCode type) manager Type ma~er ~vhich is used bv this object.
name Name of this pointer type.
type The type code of this f ~ ' ' type.
C~ , a VerP~ tal object which re,oresa~ts a ' ' ' type such as signed int, etc.
Class VcrAlias Public subçl~cc of VTypeData VerAlia~ defines an alias of anotha type. b~stances of this class will typically only be created to add additional mL~uns to special ~ersion of ' ' ~ ' t~pes for use the class re~istry. For instance, un3lgned long could have sn alias named "color" which is idaltical lo un~igned long exoept that it has mixin support for bnnung up a, " ' color editor.
Public Members VerAlias C , aVerAliaa object.
VcrAlias Constructor VcrAlia~ ( VAtomRef name, VTypeData ~ realType 1 name Name of this alias.
realType Type that this will represenL
C I a VcrAlia~ object which ~ ,. an alias of another type. The . ' - of all methods just calls the methods of the realType object. The onlv mcthDds which are not my~ped diroctly onto realType are the methods for mixin suppoTL
Class VcrPointer Public suh~l~cs of VTypeData VerPointer defines a pointa to allother type.
Public Members VerPointer C ~ - a VerPointer objecL
V~ C~ ll U~tOI
VcrPointer ( VAtomRef name, VTypeData ~ba~eType ) name Name of this pointer type.
baseType Type that this will be a pointa to.
C . a VcrPointer object which - -r- ' a pointer to another type. This should not be used for pointers to objects, instead use VerOb~eetRef. Pointers to functions should be ' with VerPunetionPtr.

SUBSTITUTE SHEE'r(RULE 263 wos6/os76s ~ Q ~ ~ PCItCAgS/OOS13 Class VcrObjectRef Public subclqcs of VTypeData VcrOb; ectRef defines a referalce (pointer) to sn instance of a panicular object t~pe.
Public Members VcrObjectRef C- I sVcrobjectRef object.
Cla~s Returns the class of object to which an instance of this type will refa.
VcrObjectRef Consl.uc~or VcrObj ectRef ~VTypeManager *manager VAtomRef name VClassData *refClassl manager T~pe manager which Is used by this object.
name Name of this ref~alce type.
refClass Clsssof-c~ ~object.
C- , ' a VcrObjectRef object which ~ a refaence (potnter) to an instsnce of the specified class.
Class VCla3~Data *Cla~s ( ) Cla~ returns the class of object to which an ir~ance of this type will refa.
Class VcrFunctionPtr Public s~b~J~cs of VlypeData VcrE unctionPtr defines a pomta to a function with a specified signature.
Public Members Vc F~.~ ~ionPtr C- ~ aVcrFunctionPtrobject.
Function Returns the function signature d p V~lF~ 1;onPtr C~lSllU~t~
Vc~n~ ionptr (~ er *manager VAtomRef name VFunctionData ~funcSig) manager Type manager which is used by this objecL
name Name of this function pointer ~pe.
funcSig Signature ~ p~ of the funclion this will point to.
C I a VcrFunctionPtr object which ..~,. a pointer to a function with the specified signahne. The c ~ . of the VFunctionData is turned o~a to this object. This VFunctionData must not be used elsewhae.
Func~ion VFunctionData *Function ( ) Functi on rehuns the d~.: of the function to which an instance of this type will point.

SUBSTITUTE SHEET (RULE 26~

wo 96/0876s 2 ~ O O O 9 ~ Pcr/cAgs/005l3 Class VcrStructItem VcrStructItem defines a field n a structure or union. It includes the field name, type, and offset into the structure. An instance of this class carmot be assigned a t!~pe code Public Members VcrStructItem C . ~ avcrstructItemobject.
Name Returns the narne of this field.
Type Returns the type of this field.
of f ~ e t Retums the offset into the structure of this field.
VcrStructTtPm Constructor VcrStructItem( VAtomRef name, VTypeData ~theType, long off et) name Name of this structure field.
theType Type of tbis structure field.
of f set Offset of this field within the structure.
Constructs a VcrStructItem object which ,~,.. a field within a structure.
Name tomRef Name ( ) Name returns the nalne of this structure or union field.
Type VTypeData ~Type ( ) Type returns the type of this structure or union field.
Offset long of f ~et ( ) of f ~et returns the offset of this field within the structure.
Class VcrStruct Public subclass of VTypeData VcrStruct deftn~ a structure teftottion. The slructure cont lins a fixed number of fields at fixed offsets from the begirming of the structure.
Public Members VcrStruct Ce ~ aVcrStruct objcc~
AddI tem Adds a fidd to the stmcture.
GetItemsyName Returns the fidd d~ r of the specified field.
Get I temsyIndex Returns the field A- - fi 1 ~n-~ ~ of the specified fidd.
GetItemCount Returns the number of fields in the structure.
VcrStruct Constructor VcrStruct ( ~yy~rsanager ~manager, SUBSTITUTE SHEET (RULE 26) W 0 96/08765 PCTIC~9S/OOS13 VAtomRef name, VcrStructItem ~iteml = O, VcrStructItem ~item2 = O, VcrStructItem ~item6 = O) manager Type manager which is used by this object.
name Name of this structure.
iteml-item6 Optional items to add to structure.
Cc . a VcrStruct object which ,~ a structure. A~er creation, fields can be added to the strucb~re to define its lavout. If anv of iteml thr~h item6 are specified then these are added to the structure defnition as if AddItem were called for each of these in sequence.
~d~llt~m void AddItem(VcrStructItem ~item) item Field to add to structure.
Add a new field to the structure. nle order in which fields are added is important since it used to ~' - type . ' ' ~v and castability.
GetTt~n RyName VcrStructItem ~GetItemByName(VAtomRef name) name Na1ne of field to retrieve.
Retrieve a fidd from the structure ~iven its name.
GeTTt~mRyIIldex VcrStructItem 1'GetItemByIndex(long index) index ~ukxoffidd to retrieve.
Retrieve a field f~om the stn~aure given its inda~ in the structure. nhe inda~ is defined by the order in which &elds were added to the structure starting from ~ero.
GelIt lllCount long GetItemCount() P~ t; number of fidds in this structure.
Class VcrEnllm~m VerEn ~mTtem de&ne~ constant which will be one of the possibk values of an type An instance of this class cannot be assi~ned a t!lpe code.
Public Mehl~.s V~rl;:nl Ttem C~ I avcrEnumItemobject Name Returns the name of the _ constant.
Value Returns the value of the - constant.

SUBSTITUTE SHEEr (RULE 26~

WO 96/08765 2 ~ n o o 9 1 PCT/CA95/00513 V~r;~ ...Tt~m ConStructor VcrEnumItem( VAtomRef name, Walue value ) name Name of this constanL
value Value of this ~ ~ constant.
C~ _ ' 8 V; - ~- object which .~ a; constant within an enum (a set of e constants).
Name VAtomRef Name ( ) Name returns the name of the constant.
Value Walue Value ( ) Value retums the ~ralue of the e conslant.
Class VcrEnum Public s~bclscs of V rypeData VcrEnum defines an npe. An npe conlains a nu nber of ~ conslants each of which has an ~ ' name and ~alue.
Public Members VcrEnum C~ a VcrEnum object.
AddItem Adds an cnum. conslant to the enum.
GetItemByName Returns the ~' "' of the specified constant GetItemByIndex Relurns the d -- r" of the specified .
constant GetItemCount Returns the number of _ constants in this enum.
v~.r... Co~slluClol VcrEnum ( VAtomRef name, VTypeData ~ VcrEnumItem ~iteml ~ O, VcrESnumI tem ~ i tem2 ~ O, VcrEnumItem ~item6 - O) manager Type mana~er which is used by this obje~L
name Name of tbis enumType Type in which the _ wilt be stored.
iteml-item6 Optional items to add to ~
C~ ~ a VcrEnum object uhich ~ a ~ After creation, constants can be added to the . to define its possible ~alues. The type of the . must be an integlal r ' ' t pe. If any of i teml throu~h i tem6 are specified then these are added to the . definition as if AddI tem were called for each of these in sequ~ nce.

SU85TITUIE SHEET (RULE 26) Ad~llt~m void AddItem(VcrEnumItem ~item~
item Constant to add to ~
Add a new constant to the _ - The order in which constants are added is important since it used to determine t~pe . . " ~ and castabilitv.
GetT~nRyName VcrEnumIte~ ~GetItemsyName ~VAtomRef name~
name Name of constsnt to rdTieve.
Retrieve a: constant from the _ ~. given its name.
GetTtçmRyIndex V~rFnl Ttem ~GetItemByIndex (long index~
index Index of constant to retrieve.
Retrieve a ~mslant from the e given its index in the . _ The index is defined by the order in which constants were added to the _ star~ing from zero.
G.,lIl~,l.Count long GetItemCount ( Returns the number of constants in this Class VcrSequence Public sllbrl~cc of VTypeData VcrSequence is an abstTact class. It defines a variable length arrsy whose length may be d ' on sn instanoe by instanoe basis. For example, strings w~uld be .' ' as VcrSequences.
VcrStructSequ~n~e is also .' ~ on top of VcrSequence. Fixed length arrays are also described as: ' of VcrSequence using VcrArray.
Public Members VcrSe~ .,ce C- . a Vcrse~ _hce- object.
GetLow-~ rRol In,l Returns the lower bound of the sequenoe.
I~otec~ed Members PutConcreteType Sds the concrete type after creation.
Ove2~idable Public Me~b.,.~ .
GetLength Returns the length of lm instanoe of the sequenoe.
Ge~MaYT.ength Returns the rnaximum len~th of the sequenoe.
GetElement Returns the specified element of the sequenoe.
I ~T.i ne:~ r Returns whether the sequenoe data is linesr.
VcrSequence Con~llu~ilor VcrSequence ( VAtomRef name, VTypeData ~concreteType, VTypeData ~baseType, SUBSTITUTE SHEET (RULE 26) _ W096/08765 ~ 2 2 0 ~ PCI/CA95/OOS13 long lbound) name Name of this sequence t~pe.
concreteType Type that this sequence is built from.
baseType Tvpe that this wiII be a sequence of.
lbound Lower bound of the sequence indices.
Constructs a VcrSequence object ~ hich represents a pointer to a variable length arrav of other instances of another type, GetLowerBound long GetLowersound ( I
Returns the lower bound of the allo~Yed sequence indices.
PutConcreteType void PutConcreteType (VTypeData ~ concreteType ) concreteType T~pc that the sequence actually is.
PutConcreteType sets the actual npe of the sequence after creation. This t,vpe is the actual npe which wouJd be stored inside structures. etc. For instance, CORBA sequences have a concrete type being a structure: ' E three elements.
GetT .çt~h long GetLength(void ~instance~ = O
instance Instance of this sequence t~pe.
GetLength retuTns the Iength of a particular instance of this sequence t~pe. This must be ~ . ' ~ ~ in - ' '~ of VcrSequence.
Get~xT .çn~h long GetMaxLength tvoid ~instance) - O
instance Instance of this sequence type.
Get~ -YT ~ngth returns the maximum Iength for a particular instance of this sequence type.
This ~DS the maximum allocated Iength of the data storage for the sequence array. This must be ' . ' ~ ' in ' ' of VcrSequ~nre GetFlçmpnt void ~GetE1ement ( void ~inatance, long index ) = O
instanee Instance of this sequence type.
index Index of element to retricve.
Returns a pointer to the specified element of the sequence. If index is outside the valid bounds of the sequcnce this will retur,n NULL.
T~ in~r bool t I YT.i n~:l r ( ) = O

SUBSTITUTE SHEET (RULE 26~

WO 9610M65 ~ PCTICA95/00513 Returns whether the sequcnce is a linear sequence of the specified n~pe. If the return is TRUE
then the second element of the sequence wlll directly follow the first in manory. If IsLinear return FALSE Ihen the sequcnce mav be sparse and can only be accessed through GetElement.
Class VcrArray Public s~lbc~cc of VcrSeql~once VcrArray describes 8 fixed len~th array. A fixed len~th arra~ must have fixed uppcr and lower bounds.
The lower bound is not rcstricted to zero.
Public Members VcrArray Ce I a VcrArray object.
VcrArray Constructor VcrArray ( VAtomRef name, VTypeData ~elemType, long lbound, long lenl name Narne of this array n~pe.
el emType Type of the elements in the array.
lbound Lower bound of the array indices.
len L0gth of the array.
C~ . a VcrArray object vhich represents an array. The array is fLxed length with a lower bound which is not required to be zero.
Class VcrStructSequence Public s~bcl~c of VcrS~ , n~
Vcrstructsequ~nre a soquence ~hich is defined as a structure . membcrs whichinclude a length, a ~ Iellgth, and a pointcr to the anay of clements.
Public Members VcrStr~ctSequ~n-e Cc ~ a VcrStructSequence object.
VcrStructSe.lue~ce Co~lluc~r VcrStructSeq~l~nre t VAtomRef name, VcrStruct ~concreteType, VcrStructItem ~length, VcrStructItem ~ cLen, VcrStructItem ~array, long lbound) SUBSrlTl1TE SHEET (RULE 26) WO 96/08765 ~ 9 '1 PCT/CA9S/00S13 name Name of this array type.
concreteType Type of the physical layout of the sequence itsel~
length Structure field which .~,.. the length of the sequence.
maxLen Fidd which represents the rna~omuru length of the sequence.
array Structure field which rcpresents a pointer to the sequence data.
lbound Lower bound of the sequenoe irldices.
C~ . a VcrStructSequence object which represents a sequence described as a structure _ _ elements for the length, maximum length, and pointer to the data. The base type of this sequence is the base type of array->Type ( b array->Type ( ) must be a VcrPointer or VcrRef erence.
Class VcrString Public ~brl~cc of VcrSequenr,e vcrstrlng is an abstract class which descrioes a variabk length string of c~ Pr'~s Each subclass can store its data in anv suitable fonnat. For instance, the C string subclass stores the string as a NULL
' linear alrav of rl~~~rt~c A Basic string would be stored as a length followed by a linear array of ~ ' Public Members VcrString C~ , a VcrString object.
VcrString Cons~uctor YcrString ( VAtomRef name, VTypeData ~concreteType, VTypeData ~ba~eType, . long lbound ) name Name of this stnng type.
concreteType Type that this string is built f~aL
baseType Type that this will be a string of. This must be either signed or ur~igned character.
lbound L~wer bound of the string indices.
C~ ~ a VcrString object used to represent a string. This class is an abstract base class upon which diffe~nt . ' of strings can be built.
Class VcrAny Public subcl~cs of VTypeData VcrAny is an sbstract class which defines a data type which can contain a value of one of sevaal types.
This type is used to define types such as OLE 2.0 V~RL~NT and CORBA any. VcrAny types csn be '~ conv~ted between each other p~ovided that the ~pe of the value being converted is contained in both types. VcrAny differs from a union in that an instlmce is not restricted to ~ a value from a fLxed, 1~ i, set of diff~ent types.
Public Members VcrAny Cc ~ " aVcrAny object Plote~led Members PutConcreteTYpe Sets the concrete type after creation.

SUBS~lTUr~E SHEE~ (RULE 26~

WO 96/08'765 PCT/CA9S/OOS13 Overndable Public Members Types Returns list of supported tvpes TypeOf Returns the type of the specified instance.
Value Returns the actual value from the specified instance.
VcrAny Consauctor VcrAny~ VAtomRef name, VTypeData ~concreteType) name Name of this type.
concreteType Concrete tvpe of this anv. Used to suppoqt passing and returning from ~ functions.
C 1 a VcrAny object which ,~,.. 8 type which can contain anv of a set of otha types. This is an abstract bDse class ~ich must be ' ' ' to define galaic types such as any and VARIANT.
PutConcreteType void PutConcreteType~VTypeData ~concreteType) concreteType Type that the any actu~ly is.
PutConcreteTypesets the actual type of the any afta creation. This type is the actual tvpe which would be stored inside structures, elc. For ins~ance, CORBA any's have a concrete tvpe being a structure c , two elements.
Types VTTypeList Types~) = O
Type returns a subset of the list of types which may be contained in this generic type. If the type can contain any o&er type then this should return an empty list. If the set of types supported is fillly dynamic then an empty list should be returned. This list should only be ' ' as a hint about what types an instance n~v contain.
TypeOf VTypeData ~TypeOf~void ~in~tance) = 0 instance hs~nee to query.
TypeOf returns the type of the value contained in an instance of this generic type. If the type cannot be described to the type _ system then TypeOf should return NU~L.
Value void ~Valuelvoid ~in~tance) ~ 0 instance ~s~nee to query.
Valueletrieves a pointer to the value contained in this generic type. This may return NULL if the instance does not contain a value.
Class VcrUnionltem Public ~ of VcrStructltem SUBSTITUTE SHEEr (RULE 26 WO 96/08765 ~ Q 9 f PCT/CA9S/00513 VerUnionItem defines a field in 8 union. It includes the field name, type, s~itch value, and offset inlo the union. The offset will typieallv be zao for most machine r ~ ..,. An instanoe of this class eannot be assigned a tvpe code.
Public Members VerUnionItem C -_ aVerUnionItemobjeeL
Value Returns the value which speeifies that this is the current union field bcing used.
VcrUnionltem Con~llu~ilor VerUnionItem( VAtomRef name, VTypeData ~theType, Walue value, long offset = 0) name Name of this union field.
theType Type of this union field.
value Switeh value of this field.
o f f s et Offset of this field within the union (if not 0).
ConstrucLs a VerUnionItem object which ~ a field ~ithin a union. If this lield is to be the "default" field if no value match is found for anotha field tha, value should be of npe kVTypeVoid.
Value Walue Value ( I
Value returns the value of the switch value for this field. If the switch itan paired with a union is this value then the union will contain a value ~ ' bv this field.

Class VcrUnion Public s~lbcl~c~ of VcrAny VerUnion defines an abstract union type definition. This serves to allow a eom~non base for all diffaent layouts of unions. For instance VerStruetUnion is a union which is itself defined as a structure. This structure has an ' ~ ' ' structure and a s~iteh field. Another type of union rnight be one which itself has no switch field. The actual switch field roi8ht be outside the union in the e type for this subelass of VerUnion.
Public Melllbl.~
VerUnion C . a VerUnion object.
VcrUnion Co~ uclo VcrUnion ( VAtomRef name, VTypeData ~concreteType) name Na~ne of this union concreteType Concrae type of this unio~
C~ . a VerUnion object which .~ a union. The concrete n~pe is the strueture whieh defines the actual layout of the union itself.

SUBS~ITUTE SHEE~ (RULE 26~

WO 96/08765 ~ PCT/CA95/OOSl3 Class VcrStructUnion Public subclqcc of VcrUnion VcrStructUnion defines a CORBA stvJe union type definition. The umon is built bv definin~ a stn~e - _ a switch field~ the field which d which sub field of the union to use, and a nested structure cont~s the fields of the actual unio~ 1 hese fields must be instances of VcrUni onI tem instead of VcrStructItem.
Public Members VcsStructUnion C~ l a VcrStructUnion object.
VcrStructUnion Co~ uclor VcrStructUnion ( VAtomRef name, VTypeData ~concreteType, VcrStructItem ~switchItem, VcrStructItem ~unionItem) name Namc of this union concreteType Concrete type of this union.
switchItem Item in struct which d~ which fidd the union currcntly contJinS.
unionItem Item in struct which is the nested structure - , the union ele nents.
C~ , a VcrStructUnion object which l~r a union. The concrete type is the stn~e which defines the actual layout of the union itsdf.
Class VcrOpaque Public subclscc of VTypeData VcrOpaque is an abstract class which defines a type of ur~nown ~' ' This class pro~rides methods which allow it to cast inst~ces to l~nown types and also to cast known types to this opaque type.
VcrOpaque ' ' are used to int~duce types into the type manag~ which are ' ' ' ' ~ in terms of the set of possible ' ' ' arld derived types. A subclass of VcrOpaque must be able to cast oth~
types to and from its internal ...
Public Members VcrOpaque Cc ~ a VcrOpaque object.
~t~tect~d Members PutConcreteTYpe Scts the concrete type after creation.
Overridable Public Members Ca~tToLi~t Returns the list of type to which this can be cast.
Ca~tFromList Re~rn the list of types which can be cast to this type.
CarlAlway~Rever~eCast D~ ' whether this type can always be cast to the specified type.
CanSometime~Rever eCaat D~ ~ whether this type may s - be cast to the specified type.
Rever~eCon~truct C~ ~ an instance of the specified type which is a correctlv cast copy of the instance of this type.
Rever~eCa~t Casts an ir~ance of this type to the specified type.

SUBSTIME SHEET (RULE 26) _ W 0 96/08765 F ~ 2 ~ O ~ 9 ~ PCT/CA9S/OOS13 VcrOpaque Constructor VcrOpaque~ VAtomRef name VTypeData ~concreteType) name Name of this type.
concreteType Con~ae type of tbis opaque type. Used to support passing and returning from functions.
C~ I aVcrOpaque object. The subclass of this type will provide . ' for all the ~irtual methods. This abstracl class just defines a .. ' for v g opaque types into the type , - svstem.
PutConcreteType void PutConcreteType(VTypeData ~concreteType) concreteType Type thst the opaque actually is.
PutConcreteType sets the actual type of the opaque after creation. This typ_ is the actual type which would be stored inside structures, or passed to functions as , This t~pe is needed to manage putting these opaque objects on the stack correctly for passing them ss ~ L and receiving them as returns.
CastToList ~ enefList CastToLiat() e 0 CaatToList returns a parlial list of types which anv instance of this type can be cast to ~vithout loss of ' 'fhis list of types can be used as a hint to a language ~ ~, to decide what to do with an instance of this type.
CaslF~ List ~yyeRefList CaatFromList() s 0 CaatFromLi~t returns a par~al list of types which can be cast to an instance of this type without loss of ~ r " This list of types can be used as a hint to a langua~e i ~ t.. to decide what to do ~,vith an instance of this type.
CanAlwaysReverseCast bool t CanAlwayaReveraeCaattVTyyeData ~type) = O
type Type to comparc to.
CanAlwayaReveraeCaat d ~ whcther the specified type can be cast to the current type in all situations without loss of ~ r ' This is the reverse direction of CanAlwayaCast. For instance a ahort can dways be cast to a long but only certainins~nces of long csn be cast to ahort. This w~d return true ~y for ahort to long.
CanSo...~ Ps~everseCast bool t CanSometimeaRever eCaat(VTypeData ~type) = 0 SUBSTITUTE SHEEr (RULE 263 WO 9610M65 PCT/C~9SIOOS13 type Type to compare to.
CanSometimeaReveraeCast d whcth~ the specified type can be cast to the - current type in some or all situations without 1055 of r " This is the reverse direction of CanSometimesCast. For instanoe a short can alwavs be cast to a long but only certain instances of long can be cast to ahort. This would return true for casting ather short to long or longto~hort.
ReverseConstruct long ReveraeConatruct( void ~instance VcrDataRef &to) = O
instance Instance of this type.
to (Input~ Return) T~pe of fuul object to be , ' and pointer to newly ~ ~ ' iteln on return.
ReverseCon~truct builds a new instance of the specified type by casting the input object of this t~pe to the requested tvpe. This performs the opposite direction of L ~ when compared to Con truct. ReverseConstruct should allocate a buffa for the new ~nedobject. The return value should be the size of the new instance. If the original instance could not be cast to this tvpe or memorv could not be allo~ated ReveraeConatruct should retum 0.
ReverseCast long ReverseCaat( void ~inqtance VcrDataRef &to) - O
instance Instance of this type.
to Tvpe of and pointer to instance to fill.
Rever eCaat builds a new instance of the specified type by casting the input object of this t~pe to the specified type. ReveraeCaat paforms the opposite direction cast when cc~npared to Ca t. ReverseCa~t should not allo~ate a buffer for the new type instance but should instead use the supplied buffer which is, 1 to be large 00ugh to fit the type. The return value should be the size of tl~e new instance. If the original instance could not be cast to this type or memory could not be allo~ated ReveraeCast should retum 0. The instance buffer passed into this routine may contain garba8e and as such should be fully c._~.
Class VTypel~n~er Public ;,~.I)c.l~c~ of VPrima~y "r~ nagermanagatype~' p~ Thisclasscanstoretype d ri andprovideuniqueid's (VTTypeCodea) for each unique type ~ ~ There will typically only be one type m~ager per pmcess.
Public Members ~y~. -n-ger C~ a v~ llanager object.
Regiater Reyisters a new type and reOlrns its VTTypeCode.
TypeDestroyed Notif~es the type manager that a type object has been deleted RegisterPersistent Registers a type with a persistent type code.
Lookup . Returns the d r " of a type given its VTTypeCode.
SameLayout rk whether the two typa are ~
(although the nalnes of ': ' may differ) SUBSTITUTE SHEET (RULE 26~

9 ~l CanAlwaysCast D wheth~ the first type can always to cast to the second type.
~ CanSometimesCast D ' ' whether the first type may " be cast to the second type, SizeOf D~' ' the size of an instance of the specified type.
Construct C~ I a copy of one type as another type.
Cast Casts an instance of one type to another type.
Empty Empties an instance of the specified type, Discard Discards an instance of the specified type.
TypeName Returns the name of the specified type, TypeHelp Returns the hdp ' ' ' of the specified type.
VType~na~r Collstructor VTypeManger() C~ ' ~c' a VTypeManager objecL After creation the type manag~ is ready to perforrn casting and to receive and store type ~' 'p~' ReglSter VTTypeCode Regi3ter(VTypeData ~type~
type Type to register, Regi~ter will register a new tvpe with the type manag~, If it is ~'- ' ' that this type is ' identical to an existing nype (using VTypeData::Identical) then this n, pe d.~.'p~' will be given the same VTTypeCode as the existing type ~vhich is ., ' . ' This will -' "y be called bv instances of types on the first request for their type code, There is no reason to call it directly, TypeDestroyed void TypeDe~troyed(VTypeData ~type) type Typc being destroye~L
TypeDe troyed notifies the type manager that a type has been des~ycd. This allows the type managa to clean up and remove stored ' ' ' used in d ' ' ' ~ type equality. Thisshould have been called before the type oyect is acb~ally freed since the type manag~ mav need to reference fields of the type. VTypeData r 'ly calls this after all ~ef~ to the type disappar but before delcting the type.
Regi~h,P~ iistertt Regi terPer~i~tent~VTTypeCode tcode VTypeData ~type) tcode Pcrsistcnt typc code for this typc type Ty, pc ~ ', " to register, Regi~terPer~i tent ~U register a type ~ '~' with the type manager. The type ~' ',a~' is given the specified type code. Ihese type codes must be allocated by Visual Edge, This method is used instald of Register so that ~ ' ' ' types can be added to the type managa. Once a pe~istent type object is added to the type manay~ it will exist as long as the type manager exists. The f ~ ' type objects ~ y call this method on creation so there is no need to call it directly.

SU8STITUIE SHEEr (RULE 26) wo 96/08765 ~ rCT/C~9S/OOS13 Lookup VTypeData ~Lookup(VTTypeCode type) type Type to lookup.
Lookup returns the type defiDition for the specified type code and return it. If this type is a ' ~ type or is currently undefined in this type rnaDag~ NULL will be returned.
.S~m~l ~yout bool t SameLayout( VTTypeCode typel, VTTypeCode type2) typel First type to use for - , type2 Second type to use lor;
sameLayoutd whether Ihe specified types are identical in lavout. This should return true if all subtypes, sub fields, and offsets match Names and help ' should not be - . ' This method is cslled to det~noine castirlg F~ ;t;- _ CanAlwaysCast bool t CanAlway~Ca~t( VTTypeCode typel, VTTypeCode type2) typel First type to use t'or type2 Socond type to use for _ .
CanAlway~Cast~' wheth~ the first type can be cast to the second type in all situatio~s without loss of r '' For instance a ~hort can always be cast to a long, but only certain instances of longcnn be cast to ~hort. This would return true only for ~hortto long.
CanS~ ,h~..P jCast bool t CanSometi -3C~t( VT$ypeCode typel, VTTypeCode type2) typel First type to use for c type2 Second type to use for: .
CanSometime~Ca~t~'~ whether the first type caD be cast to the second type in some or all situations without loss of ' For instance a ~hort can always be cast to a long, but ollly c~blin ins~ances of long ca~ be cast to ~hort. This would return true for casting dther ~horttolong or longto3hort.

long Alignment~ LCode type) type Type to get aligmnent for.
Alignment raurns the JligDment required for instances of this type. The l~'i, specified in Dumber of bytes. For example an eight b~yte double might be able to be aligned on four byte b ' in which case this method would return four. The lowest possible ~ralue is one.
SizeOf long SizeOf( V$TypeCode type, SUBSTITUIE SHEE'r (RUI~ 26) WO 96/08'765 ~ PCT/CA9S/OOS13 void *instance = 0) - -type Type of the instance.
instance Pointer to instance to use for~ size.
SizeOf retwns the size of a par~cular ins~ance of the type. If the instance pointer is NULL then sizeOf should retwn the s~ze of all ins~nces of the type if the size is fixed. If the s~ze of instances is ~anablc SizeOf should retwn O or negative.
COIlS~UCt long Construct( VTTypeCode origtype, void *original, VTTypeCode newtype, void **instance) origtype Type of original object to use for copyiug.
original Pointer to original object to copy fmnL
newtype Type of targn object.
instance (Rdwn) new ~ns~nce of targd type.
Construct builds a new instsnce of the taT~et type by casting the input object to the targn type. Construct should allocate a buffer for the new retwned object. l he return value should be the size of the new inslance. If the or~ginal instance could not be cast to the target type or memory could not be allocated Construct should retwn 0.
Cast long Cast( VTTypeCode origtype, void *original, VTTypeCode totype, void ~in~tance) origtype Type of original oyect to use for copying.
original Pointer to origi~l object to copy fram totype Type of t~gn object.
instance Pointer to where to store the inst~nce.
Caat builds a new instance of the targa type by casting the input object to the targn type. Caat should not allocate a buff~ for the new type instance but should instead use the supplied buffer which is ~ ' to be large enow~h to fit the type. The retwn l~alue should be the size of the new instsnce. If the origi~l instance could not be cast to the tllrgn t~pe or memory could wt be ~llocated Caat should return 0. The instance buffer passed into this routine may contain ~arbage and as such should be fullyo._~
Empty void ~mpty( VTTypeCode type, void *inatance) type Type of the instance.
instance Instance of type to be emptied.
Empty empties out the contents of an instance of the type. This should free all memory allocated within the inst~nce but it should not free the instance it~el~ To free the instance itself Discard should be called inslaKI

SUBSTITUTE SHEE~ (RULE 26~

wo 96/08765 ~ 1 PCT/CA9S/OOS13 Discard void Discard(VTTypeCode type, void ~ in~tance ) type Type of the inst~mce.
ins tance In~ce of type to be discarded.
Di~cardemptiesoutthecontentsofaninstanceofthetype. This villfreeallmemoryallocated ~vithin the instance and will free the instance itself.
TypeName V~tomRef Iy~erl - (VTTypeCode type) type Type to gd r ' about.
TypeName retrieves the n~ne of the spccified type. If the n,pe is a derived type, the name is retrieved frolo the VTypeData object ~,vhich defines the type.
TypeHelp VcrHelp ~ Iy~ c}lc lp (VTTypeCode ) type Type to gd ' ' " abou~.
TypeHelp retrievcs the help ' ' ' ' for the specified t!~pe. If the nype is a derived type, thc help object is re~lieved from the VTypeData object ~vhich defines the type. NULL is rehuned for the ' ' ' ' types.

SUBSTI~UTE SHEET tRULE 26) WO 96/08 76~ 9 ~ PCT/C~95/00513 Mixins Class registry elements are all able to support mKins. These mixins can provide additional r ~ V
not defined in the base class registry. For ex~nple, rm~ns can be defined to support, ' ' editing tools on types, for example a color editor on an integer tyF7e. Visual Edge will be wcq1cing with its partners to define standard suites for mixins (analogous to Apple Event Suites) -- increasing a~F' ~
~ r ~ 1. MKins each have a unique ID. Any vendor can define there own mi~cins for class re~istrv entries and publish the definition and ll) so that other vendors can . ' the f ' v in their systems. Vendors who want to define standard mKin suites can request blocl~s of IDs from Visual Edge.
Class VcrQuelyMixin Public s~bcl~cc of V~x~
VcrQueryMixin is an abstract class which is used to query the class registry about the entries it "sees"
--including objects in the class registry structure itself. The details of this mixin have not vet beal :' ~ ' The query rnixin definition is intcnded to provide enough detail to allow queries as comple~ as OQL (ODMG '93 Object Query Language) ~7elect...where queries while still providin~ the capabilin to perform the queries ', ' ~ of anv particular query language. Another ~oal of the querv extension is to allow the queries to be easilv translated into any specific query language (such as SQL, OQL, ~
object specifier records, etc.). This capability would allow each object s~stem to . ' ~ the query mKin in such a wav as to use their native ' to perform queries. A default . ' will, exist to ~ ~ items in _ " and match theln to a query (alWt slowly).
The query mKin can be found on VClassData, VAdapterNameSpace, WiewNameSpace, andVCla~Registry objects.
For class registry queries,. uhen . ' ~ an object systan adapter, if the object system does not support complex queries inherently, a default qua~ mixin can bc created for views and adapters. This default riixin . all the classes in a ne spa~ or object sva It then matches the query to he indi~,ridual item. Although this p~duces slow queries it returns correct results.
For object class instances (dscribed in the clsss registry) which support some form of queries, a version of this rnixin can be attached to thc VClas Data. This allo~s code to query instance ~ _' in a system ' . ' ~ way. A default version of this mKin will be p~vided which can be used as long there is a ~ ~ to . ~ the contents of an instance's collection I , L
Class VcrExposureMixin Public s~lbç1~cc of VM~
Vc~E~.l,G.,.IreMixin is an abstract class which is the mixin uscd to explicitly expose class c ~ ~
and n~ fmm anoth~ object system to tbis object systern (i.c the object system the mixin is designed for).
The exposure rnixin is availabk on the VAdapter~ -Spac~ andVCla~Registry objects. The VCla~sRegi~try~ .' ~ cycles thr~h aU adapters F r ' g the same operation on each adapter.
The exposure D also provides support for creating native proxy objects (i.e. objects in this object system) around foreign objects (i.e. objects in another object system). This enables objects in anoth~ object systeTn to appear to objects in this object systcn ~ . ' ~ 1~ as if they are "native" to this object systan..
The proxy simply rnaps calls to/froTn this object system onto the actual object using the class repstry supp~t in VcrCall and VcrCompleteCall to caU the actu~ object's methods and propcrties.

SUBSTITUTE SHEE~ (RULE 26) a W0 96/08765 ~ !I PCI/C~gS/OOSl3 The exposure mixin provides a means to expose . ' ' i ' ' to this object svstan. That is, ' ' ' about what pro@am to rlm, etc. to create an instance of a particular class. Included in this f ' ''~ is the ability to explicitlv Identify an instance as the "on~ which was created to satisfv a "run ~ . ' ' ' ~ roquest.
An object system adapter can support some, all, or none of the exposure mixin. If the object syste n does not prov~de the capability to do anv of this ~ ' '' v then the mixin should simply not be provided on the adapter.
In addition to ~r,, " e the exposure mixin, object system adapters may provide the capabilitv to 1~ expose objects. That is, if an object from anotha object system is passed into a method or property of thus object system, the adapter may choose to ~ y build a proxy object arolmd the foreign oyect and pass that to the method or property. To the user of the class registry i . . exposing allows object systans to appear s ' ',~. ' , ' Using b . ' exposure and the class registr~
allows instances from one object svstem to be passed to another object s,vstem vithout an,v special .~ ' in between.
Ove~idable Public Members ExposeDefinition Exposes a class registry definition to this object s,vstem.
ExposeSube1ass Exposes a class registry definition to this object svstem as if it is a subclass of one of this system's classes.
ExposeApp1ieation EYposes an dj ~ ' ' as a source for - l " e instances of a particular class.
ExposeFaetory EYPOSeS a class at runtime so that instances can be build from this object systa~
Expo eInstance Exposes an object instance at runtime to be callable from this object system.
HideDefinition Hides an exposed class registry definition from this object system.
HideApplication Hides an a~ . '' ' as a source for ~ instances of a particular elass.
HideFactory Hides an exposed elass factory so that instances can no longer be build from this object systa~ -HideIn~tance Hides an exposed object instance so that it is no lon~er callable from this objoct syst~nL
IsDefinitionExpo ed Rdurns whether a fareign class has already been exposed to this adap~er.
App1ieationExposed Rdw whether a particular ~j . '' '' has already been exposed to this adapter.
AequireProxy Builds a ~xy objoct in this object system for this instance which is from ~other objoct sy~
Re1easeProxy Rdeases an e~ng p~xy ob~ct ConstruetNameSpaee Builds a name spt~oe m this object ~
Inst~n~ nel eted Notifi~ the uhp~r that an object inst~ce has been deldod.
Ur~apForeign Remo~re all ~_f~ to an e~nal item which may be used in exposure caching.
UnmapAllForeign Remove all f~ to external items which were used in exposure c~g.
iseDefinitinn statu3 t ExposeDefinition (VcrToplevel ~item, VTToplevelRef ~expo ed) - O

SVBSTITUTE SHEEr (RULE 263 W0 96/08765 r ~ PCT/CA9SIOOS13 item Itemtoexpose to this object system.
exposed (return) Item as found in this obJect system.
ExpoqeDefinition exposes itemto this object s~te n. Once it is exposed, the return argumerltexposed should be filled with a reference to the exposed definition as if it is fnnn this object s,vstem. For instance, if item was an OLE class d~ , vOl eClassData and this object system is DSOM. expo~ed should be a VSOMCla~sData which ~ ~ the chss as a DSOM class. If item has already been exposed this method should succeed and return the exposed item. If exposing a definition is not supported this method should return NotSupportedStatus. If the exposure succeeded then OkStatus should be returned.
ExposeSubclass ~tatus t Expo3eSubclass( VClassData ~cls VClassData ~super VTClasQRef ~exposedl = O
cls Chss to expose to this object syste~n.
super ~ to use as - . ' of cls.
exposed (retum) class as found in this object svstem Expo3eSubcla~s exposes cl~ to this object svstem as if it u~ere a subclass of super.
super must be a class from this object system. cls must have .. , ' ' all the methods of super uith its ou~n vasion otherwise this call can fail. Exposing a foreign class as a subchss of a native class allows a chss from anoth~ object svstan to sppear as if it is a simple subclass of an class from this object svstem. This r ~ ~ can be used in ~ I"~t;,, or mixin r .., ' to allow abstract chsses and mixins to be i , ' ' ' in any object system. If c13 has alreadv been exposed this method should su~ceed and return the exposed item. lf exposing a foreign class as a subchss is not supported this method should return NotSupportedStatu .
If the exposure succeeded then OkStatu3 should be returned.
ExposeApplication -~tatus t Expo eApplication( VCla~JData ~expoJed con t char ~: ~r con t char ~appFile con~t char ~hostName bool t multiple) - 0 exposed Class of objoct to be exposed to this object svstem.
appName Nalne of the ~, '' "
appFile Filen~ne ofthe ~, '' ' ~ ' '-hostName Host on which 1, . '' ' should run.
multiple Allolv this ~4 . '' ' to be exposed for rurm~ng on mulbple -r named hosts at the same time.
E~o~eApplication c~x~cs an ui,'' " to this object sys,tem. This ~ spe~fies that this 'i.'' " can be run to create ir~nces of expo d. expo~ed should not be a V~le--D~ta ~turned by Expo eDefinition or Expo~eSubclas but should ins~ad be the orign~ VCla~ Data. a,~ -spe~fi~ the readable name of the li, '' " to be used in this systems . "' ' facilit,v. Different values of the hostName variabk can result in three different behaviors:
~ If the ~ . '' ' should be run by this object syste~n on a particular host the host nalne should be specified irl hoJtName.
~ If the 1,, '' ' shauld be run locally on whateva host makes the request ho~tName sho~d be NULL. multiple is ignored in this o~.

SUBSTI~UTE SHEET tRULE 26~

WO 96/08765 ~ PCT/CA95/OOS13 ~ If the aFF' -- should always be run on the current host e~en if the object is requested fiom another host then hostName should be a stling _ a single period (i.e. ~
If the ~ S reustered uith multiple as TRUE then ExposeApplicatiorl can be caUed with multiple different host names. If this is allowed then the . . ' can be run on any one of the specifies hosts. If multipleis F~SE then each call to this method with a different host name replaces the last defmition so that therc is only one r '~ ~Iy =ed host on which the ~ - can run.
If the ~,.' has alleady been exposed tbis method should update the definition to set the conect host and filename and then it should return OkStatus. If the adapter does not support the ~quest made bv a call to this method then it should return NotSupportedStatus. If the exposure ~ ' 1 then OkStatus should be returned.
ExposeFactoly ~tatus t ExposeFactory( VCla3~Data *exposed void **factory) = 0 exposed Class to expose a factory for.
factory (return) Factory object. f~m this object system ExposeFactory exposes the current process as being a source of objects of class exposed.
This factory onlv exists for the lifetime of the pTocess. exposed should not be ~VClassData ~turned by ExposeDefinition or ExposeSubcla~s but sho~d instead be the real one.If the factory has already been exposed then this method should store the currentlv exposed factoTy in factory and retum OkStatus. If the adapter does not support the request made by a call to this method then it should return NotSupportedStatus. If the exposure succeeded then OkStatu sho~d be ~ned.
ExposeTn~ e ~tatu~ t ExposeInstance( VCla~D2ta *exposed void *instance bool t multiUse) - 0 ~ exposed Class to expose an instance of.
instance Instance of expo-ed to expose to this object system.
multiUse Whetha this instance can be used by multiple ~ or not.
Expo~eInstance exposes a particular instance of exposed to this object system. The instsnce can be used as the one ~runn~g instance~ of the class for the lj r~' ~' expo ed should not be a VCla3sData ~ned by ExposeDefinition or ExposeSubcla s.
exposed and instance sho~d be the ac~l ori~al values. If the adapter does not support the ~quest made by a call to this method then it should retum NotSupportedStatus. If the e~osure :~' ' or the instance had already been exposed then OkStatus should be re~Dod There should only be one inst~mce of this class exposed us~ng ExposeInstance. If multiU~eisFAlSEtheDo~yone clialt sho~d be a~o~ved to use the object. ~multiU~eisTRUE than multiple clients can all use the obje~
HideDçfinition status t HideDefinition(VcrToplevel *exposed) = 0 SUBSTITUTE SHEET (RUI E 26~

WO 96/08765 ~ 9 ~ PCT/CA9S/OOS13 exposed It~n ~ exposed to this object syst~n.
HideDefinition hides a ~ , exposed item from this object system.
HideDefinition can be applied to items returned by ExposeDefinition and ExposeSubc1ass. If the adapter does not support the request made by a call to this method then it should re0~n NotSupportedStatus. If the hide ! ~ ~ then OkStatus should bc returned HideApplication status_t HideApplication ( VClassData ~exposed const char ~a~ ~r -, const char ~ appFile const char ~ho~tName) = 0 expos ed Chss of object ~.~. ivual~ exposed to this object syst~
appName Naunc of the 1PF
appFile Filcname of the ~
hostName Host on which 3~ 'as specified to run.
HideApplication hides a r~ er~posed . r ~ ' frvm this object s~stan. appName specifies the rcadable name of the arF --- as ~ passed to Expo~eApplication.Different values of the hos tName variable can result in four diffcrent beha-riors:
~ ~ If ho tName is a specific host name then the 1~, definition for running on that host should bc rano~cd.
~ If ho tName is NULL then the locally runable definition of the ~ r ~ ' ~ ~ should be hidden.
~ If ho tName is . then the a~r~' " deftnition for running on the current host should be rerno~red.
~ If hostName is ~ then the ~r~ definition for running on all defined hosts should be ranoved.
If the adapter does not support the request rnade by a call to this mdhod then it should return NotSupportedstatus. If the hidc succeeded then OkStatu shauld be returned HideFactory statu~ t HideFactory (VC1as-~Data ~exposed) - 0 exposed Class of ~ .. . 1~ exposed factory.
HideFactory hides a ~... 1~ exposed factory object. expo.~ed should be as specified in a call to Expo~eFactory. If the adapter does not support the req~st made by a call to this rnethod then it should retu~ NotSupportedStatus. If the hide theu OkStatus should be ret~ned Hi~Tnc~n~e statu _t HideIn tance ~void ~in tance) = 0 instance ]nslance as ~ 1. exposed to the nati.re object systan.
HideInstance hides a ~ ... 'y e~;posed instsnce from the native object syslan.
instance should be the itan passed into ExposeIn3tance. lf the adapter does not support the request rnade by a call to this method then it should return NotSupportedStatus. If the hide ~ then OkStatus should bc returned SUBST TUTE SHEET (RULE 26~

WO 96/08765 ~ J ~ ~ PCT/CA9S/OOSl3 IsDefini~ionExposed bool t IsDefinitionExposed(Vcr~oplevel *item) = 0 item Itcm to check for exposure to this object svstem IsDefinitionExpo-~ed checks whether this item has been exposcd to this object systan before. This call ailows code to check if its exposures have been done before. If the item exposures have p... '~ been done then thev do not need to be repeated.
IsApplicationExposed bool t IsApplicationExpo~ed( VClassData *exposed, const char *a~pr -, const char *appEile) = 0 exposed Class of object to check.
appName Name of the l . r appFile Filename of the ~ r ~ e IsApplicationExposed checks wheth~ this class and qrF' . a~l has been exposed to this obJect svstan before. This cail ailows code to checi~ if its exposures have been done before. If the ~j, ' exposures have t,.~ been done then thev do not need to be repeated.
AcquireProxy status t AcquireProxy( VClassData *exposed, void *instance, void **proxy) - 0 exposed Ciass to build a proxv for.
instance ~mce of exposed to build the pro~ for.
proxy (rctmn) P~xy object which ~ instance.
AcquireProxy builds a proxy as an object of this object svstcm. This proxy .. , the particuhr inslance of expo~ed to this object systan. If the adapter does not support the request made by 8 call to this method tha, it shouid return NotSupportedStatus. If the proxy w.~ ' ' or the inst1mce had a t,.- e proxy than OkStatu~ shouid be ~lrci The p~xy must be disposed of with ReleaseProxy.
ReleaseProxy status t ReleaseProxy~void *proxy) = 0 proxy Pr~y object which l~r~ ' an instance of anotha ciass.
ReleaseProxy rclo~s a proxy p.~ rievcd with AcquireProxy. If thc adapta does not support tile ra~ucst madc by a call to this method than it should return NotSupportedStatu~. If Ihe proxy release succceded than OkStatu~ should bc returned.
Construc~NameSpace status t ConstructNameSpace( const char *spaceName, VTAdapterRef *nameSpace) = 0 SUBSTITUTE SHEEl (RULE 26~ .

W096/08765 r 2 2 ~ ~ ~ g ~ PCT/CA95/OOSl3 spaceName Name of the oew name space, nameSpace (Return) Newlv - x' name space.
ConstructNameSpace constructs a new narne space inside the current one. This narne space can be used as the location to store cxplicitly exposed classes. If the adapt~ does not support the request made bv a call to this method then it should return NotSupportedStatus. If the n~me space creation succeeds or L e name space alreadv existed then OkStatus should be retumed, Tn~n~eDeleted void In~tanceDeleted (void ~in tance) = O
instance Instance which is being deleted.
In~tanceDeleted notifies the adapter that instance has been deleted. This allows the adapter to destro,v 811 associated proxv objects which w~e created through t. . . exposure.
UnmapForeign void UnmapForeign (VcrTop1eve1 ~item) = O
item Itern which may have been exposed to this object system.
UnmapForeign removes all ref~ences that the adapter ma,v have to item This method is provided to allow pcriodic adapt~ cache purges to limit memory ~ , ' in long running smr~ processes.
UnmapAllForeign void UnmapAllForeign ( VTObjectSystem sy tem = kVAnyObjectSystem) = O
system Object system to remow referellces to.
UnmapAllForeigrl removes all refcrences that the adapt~ ma,v have to items from the specified object s,vstem. This method is pro~rided to allow periodic adapt~ cache purges to limit memory ,r ' in long running sava processes.

SUBSTITUTE SHEEr (RU~E 263

Claims (23)

We claim:

1. A device in a digital computer enabling the use of objects from a second object system by mechanisms of a first object system, the device comprising:
description means for providing a description of pertinent classes and types of the second object system;
proxy means for creating a proxy object that is an object in the first object system and that corresponds with an object in the second object system; and forwarding means for forwarding manipulations of the proxy object in the first object system to the corresponding object in the second object system by utilizing the description.

2. A device according to claim 1, enabling the use of objects from an arbitrary number of other object systems by mechanisms of a first object system, wherein:
(a) the proxy means contains means for creating a plurality of proxy objects, each one being an object in the first object system and corresponding with an object in one of the other object systems; and (b) the forwarding means contains means for forwarding manipulations of one of the proxy objects to the corresponding object in one of the other object systems.

3. A device according to claim 1, to enable the use of objects from a first object system by mechanisms of an arbitrary number of object systems.

4. A device according to claim 2, where the device includes means for adding or removing support for object systems without compilation of the device.

A device according to claim 3, where the device includes means for adding or removing support for object systems without compilation of the device.

6. A device according to claim 3, to enable the use of software not implemented in an object system by mechanisms of an arbitrary number of object systems.

7. A device according to claim 1, where the forwarding means further includes:
means for transferring control flow from the software initiating the manipulation to the device;
means for retrieving semantic information from the call stack following the conventions of the first object system;
means for placing the semantic information on the call stack following the conventions of the second object system and utilizing the description;
means for executing the manipulation of the corresponding object; and means for returning results, if any, to the software initiating the manipulation.

8. A device according to claim 7, where the proxy means further includes means for associating the proxy object with the description of the corresponding object in the second object system.

9. A device according to claim 8, where the means for placing the semantic information on the call stack further includes:
means for traversing descriptions which are not compiled into the device; and means for placing the semantic information on the call stack according to such description.

10. A device according to claim 7, where the means for placing semantic information on the call stack further includes means for converting semantic and language types from those used in the first object system to those corresponding in the second object system.

11. A device according to claim 10, where the means for converting semantic and language types further includes:
means for converting between object types; and means for triggering the creation of a new proxy object.

12. A device according to claim l, where the device further comprises at least one of:

means for mapping between fundamental calling mechanisms; and means for mapping between low level calling conventions;
used in combination with at least one of:
means for mapping between differences in semantic types;
means to dynamically construct proxy objects when required;
means for mapping between differences in errors and exceptions; and means to mapping between differences in querying for object information.

13. A device according to claim 1, where the device further comprises means for mapping between different fundamental calling mechanisms of object systems.

14. A device according to claim 1, where the device further comprises means for mapping between fundamental calling mechanisms used in combination with means to map between differences in language types.

15. A device according to claim 1, where the device further comprises means for using features that are provided in the second object system, but are not provided in the first, in the first object system.

16. A device according to claim 1, where the device further comprises means for using features provided by the first object system which require functionality of the proxy object, where such functionality is not implemented by the corresponding object in the second object system.

17. A device according to claim 16, where the means to provide features further includes:
means for associating an object with one or more elements of the description; and means for delegating the execution of the feature by the proxy to the associated object, whether before, instead of, or after the execution of a manipulation.

18. A device according to claim 1, where the corresponding object is implemented using an interpreted language environment or runtime.

19. A device according to claim 2, further comprising a traditional application or object class construction environment, to construct applications or object classes and including at least one of:
means for subclassing from object classes from an arbitrary number of object systems;
means for utilizing or incorporating object classes from an arbitrary number of object systems; and means for instantiating and embedding object instances from an arbitrary number of object systems.

20. A device according to claim 19, to construct objects enabled to be used by mechanisms of an arbitrary number of object systems.

21. A device according to claim 2, further comprising means for organizing objects and classes from a plurality of object systems into a unified viewing space.

22. A device according to claim 9, to enable the relocation of object classes and objects among application processes, server processes and object systems.

23. A method in a digital computer enabling the use of objects from a second object system by mechanisms of a first object system, the method comprising:
providing a description of pertinent classes and types of the second object system;
creating a proxy object that is an object in the first object system and that corresponds with an object in the second object system; and forwarding manipulations of the proxy object in the first object system to the corresponding object in the second object system by utilizing the description.