Differences Between UNO and Corba

OpenOffice.org Developer's Guide

Advanced UNO

< Previous Section

Next Section >

• Language Bindings

• Implementing UNO Language Bindings
• UNO C++ Bridges
• UNO Reflection API
• XInvocation Bridge

• Example: Python Bridge PyUNO

• Implementation Loader
• Help with New Language Bindings

• Differences Between UNO and Corba
• UNO Design Patterns and Coding Styles

< Previous Page

Next Page >

This subsection discusses the differences between UNO and CORBA by providing the fundamental differences and if the different concepts could be mapped into the world of the other model. Consider the following feature comparison. The column titled "Mapping possible" states if a feature could be mapped by a (yet to be developed) generic bridge.

	UNO	CORBA	Mapping possible
multiple inheritance of interfaces	no	yes	yes
inheritance of structs	yes	no	yes
inheritance of exceptions	yes	no	yes
mandatory base interface for all interfaces	yes	no	yes
mandatory base exception for all exceptions	yes	no	yes
context of methods	no	yes	no
char	no	yes	yes
8 bit string	no	yes	yes
array	no	yes	yes
union	no	yes	yes
assigned values for enum	yes	no	yes
meta type 'type'	yes	no	yes
object identity	yes	no	no
lifetime mechanism	yes	no	no
succession of oneway calls	yes	no	no
in process communication	yes	no	no
thread identity	yes	no	no
customized calls	no	yes	yes
less code generation	yes	no	no

• Multiple Inheritance

CORBA supports multiple inheritance of interfaces, whereas UNO only supports single inheritance.

Mapping: Generates an additional interface with all methods and attributes of the inherited interfaces that must be implemented in addition to the other interfaces.

• Inheritance of Structs

In contrast to CORBA, UNO supports inheritance of struct types. This is useful to define general types and more detailed subtypes.

Mapping: Generate a struct with all members, plus all members of the inherited structs.

• Inheritance of Exceptions

CORBA does not support inheritance for exceptions, whereas UNO does. Inheritance of exceptions allows the specification of a complex exception concept. It is possible to make fine granular concepts using the detailed exceptions in the layer where they are useful and the base exception in higher levels. The UNO error handling is based on exceptions and with inheritance of exceptions it is possible to specify 'error classes' with a base exception and more detailed errors of the same 'error class' that inherit from this base exception. On higher level APIs it is enough to declare the base exception to specify the 'error class' and it is possible to support all errors of this 'error class'.

Mapping: Generates an exception with all members, plus all members of the inherited exceptions. This is the same solution as for structs.

• Mandatory Base Interfaces

UNO specifies a mandatory base interface for all interfaces. This interface provides acquire() and release() functions for reference counting. The minimum life time of an object is managed by means of reference counting.

• Mandatory Base Exception

UNO specifies a mandatory base exception for all exceptions. This base exception contains a string member Message that describes the reason for the exception in readable format. The base exception makes it also possible to catch all UNO exceptions separately.

• Method Context

CORBA supports a request context. This context consists of a name-value pair which is specified for methods in UNOIDL. The context is used for describing the current state of the caller object. A request context provides additional, operation-specific information that may affect the performance of a request.

• Type char

UNO does not support 8-bit characters. In UNO, char represents a 16-bit unicode character.Mapping: To support 8-bit characters it is possible to expand the TypeClass enum to support 8-bit characters and strings. The internal representation does not change anything, the TypeClass is only relevant for mapping.

• 8 bit string

UNO does not support 8-bit strings. In UNO, string represents a 16-bit unicode string.

Mapping: The same possibility as for char.

• Type array

UNO does not support arrays at the moment, but is planned for the future.

• Type union

UNO does not support unions at the moment, but is planned for the future.

• Assigned Values for enums

UNO supports the assignment of values for enum values in IDL. This means that it is possible to use these values directly to specify or operate with the required enum value in target languages supporting this feature, for example, . C, C++.

Mapping: Possible by using the names of the values.

Content on this page is licensed under the Public Documentation License (PDL).