CORBA Object-by-Value An overview of the value type and its IDL-to-C++ mapping. George Edwards <g.edwards@vanderbilt.edu> Institute for Software-Integrated Systems Vanderbilt University

What is Object-by-Value? Object-by-Value (OBV) is the CORBA mechanism for enabling objects to have pass-by-value semantics in CORBA operations. Conventional CORBA objects always have pass-by-reference semantics. The IDL keyword valuetype declares an object that will be passed by value. Valuetype instances are guaranteed to be local to the context in which they are used. Vanderbilt University

Object-by-Value Semantics OBV implies similar semantics to pass-by-value in standard programming languages. The receiving entity of a valuetype parameter (or returned object) instantiates a new object with identical state to the parameter. The new instance has a separate identity and no relationship to the caller’s parameter. OBV requires that the receiving entity have access to an implementation of the valuetype. Vanderbilt University

When to Use Valuetypes Valuetypes are often useful when: An application needs a “copy” of an object. An object’s primary purpose is encapsulation of data, rather than operation implementations. An application needs the performance predictability of local method invocations. An application needs to transfer an arbitrarily complex or recursive tree, lattice, or other graph data structure. CASE STUDY: Valuetypes in the CORBA Component Model CCM employs valuetypes for events and cookies. Events are messages that are transmitted asynchronously between components. Cookies encapsulate port connection ID information. Vanderbilt University

Basic Valuetype Capabilities Valuetypes in CCM (cont.) An abstract valuetype serves as a base for all event types. When a IDL eventtype is declared, a valuetype that inherits from EventBase is implied. module Components { abstract valuetype EventBase {}; }; Cookies store connection identifiers as a sequence of octets: valuetype Cookie { private CORBA::OctetSeq cookieValue; An IDL valuetype can: have operations, public and private attributes, and factories. be recursively defined. be declared abstract. inherit from a single concrete valuetype. inherit from multiple abstract valuetypes. Vanderbilt University

Valuetype C++ Mapping (1/3) An IDL valuetype maps to an abstract base class with the same name... class Cookie : public virtual CORBA::ValueBase { // ... protected: virtual void cookieValue ( const CORBA::OctetSeq &) = 0; virtual const CORBA::OctetSeq& cookieValue (void) const = 0; virtual CORBA::OctetSeq& cookieValue (void) = 0; Cookie (void); virtual ~Cookie (void); }; Inherits from CORBA::ValueBase. Pure virtual methods corresponding to operations. Pure virtual accessor and modifier methods corresponding to state members. Protected default constructor and destructor. Vanderbilt University

Valuetype C++ Mapping (2/3) …a class with “OBV_” prepended to the fully-scoped name… namespace OBV_Components { class Cookie : public virtual Components::Cookie { // ... protected: virtual void cookieValue ( const CORBA::OctetSeq &); virtual CORBA::OctetSeq& cookieValue (void); Cookie (const CORBA::OctetSeq&); private: CORBA::OctetSeq _pd_cookieValue; }; Inherits from the abstract base class. Is abstract if the valuetype has operations; concrete otherwise. Provides default implementations of accessors and modifiers. Provides a protected constructor that initializes state members. Vanderbilt University

Valuetype C++ Mapping (3/3) …and a factory class with “_init” appended to the valuetype name. Inherits from CORBA::ValueFactoryBase. Each factory method declared in IDL maps to pure virtual method that returns an instance of the valuetype. Must be registered with the ORB via ORB::register_value_factory(). class Cookie_init : public virtual CORBA::ValueFactoryBase { public: Cookie_init (void); virtual CORBA::ValueBase * create_for_unmarshal (void); protected: virtual ~Cookie_init (void); }; Vanderbilt University

Unmarshaling Valuetypes ValueFactoryBase declares a pure virtual create_for_unmarshal() method. The ORB calls create_for_unmarshal() to create an instance of a valuetype received as a parameter or return type. The factory class is concrete for valueboxes and valuetypes that have no IDL factories or operations; an implementation of create_for_unmarshal() is generated. Otherwise, the programmer must provide an implementation of create_for_unmarshal() and any factories declared in IDL. class ValueFactoryBase { public: void _add_ref (void); void _remove_ref (void); virtual CORBA::ValueBase * create_for_unmarshal (void)=0; virtual CORBA::AbstractBase * create_for_unmarshal_abstract(); }; Vanderbilt University

Abstract Valuetypes An IDL valuetype can be declared abstract. interface valuetype single multiple Have only operations – no state or factories. Have no generated OBV_ classes. Are not subject to single inheritance restrictions. Are inherited as public virtual base classes. Cannot be instantiated; cannot be parameters or the return type of an IDL operation. Essentially just a bundle of operation signatures. Vanderbilt University

Supporting a Concrete Interface A valuetype is declared to support a concrete interface with the IDL keyword supports. A valuetype that supports a concrete interface is NOT a subtype of the interface and is NOT substitutable. The interface’s operations are mapped to pure virtual methods in the valuetype ABC. A skeleton (POA_) class is generated for the valuetype that inherits from the interface skeleton. The valuetype can be registered with a POA and manipulated via an object reference of the interface type; pass-by-reference semantics apply. Vanderbilt University

Supporting an Abstract Interface Valuetypes can support multiple abstract interfaces. Abstract interfaces inherit from CORBA::AbstractBase, not CORBA::Object. Abstract interfaces have unique parameter passing semantics to their operations. A valuetype that supports an abstract interface IS a subtype of the interface and IS substitutable. Allows determination of pass-by-value vs. pass-by-reference semantics to be made at run-time. Vanderbilt University

Reference Counting Valuetypes must fulfill the ValueBase reference counting interface with custom implementations or mix-in classes. CORBA::ValueBase declares pure virtual _add_ref() and _remove_ref() methods. CORBA::DefaultValueRefCountBase can serve as a base class for valuetypes that will never be registered with a POA. PortableServer::ValueRefCountBase must serve as a base class for valuetypes that will be registered with a POA. Vanderbilt University

Other Features A valuetype with only a single state member is a “valuebox.” Any IDL type except a valuetype can be boxed. Valueboxes may not be a subtype or base type. Valueboxes for string and wstring are included in the CORBA module as StringValue and WStringValue. A programmer can provide custom code to marshal and unmarshal valuetype instances. A valuetype that is declared custom in IDL implicitly inherits from the abstract valuetype CustomMarshal. The concrete valuetype must provide implementations of the marshal () and unmarshal () operations. Intended to facilitate the integration of legacy code. Vanderbilt University

Conclusions The valuetype is extremely useful, but: Questions? Has some convoluted mapping rules. Doesn’t totally solve the original problem. Standard CORBA objects still can’t be passed by value. Has some questionable features. Questions? Vanderbilt University