NAME

CORBA::Object::create_request - (operation) create a CORBA::Request pseudo-object for use with the dynamic invocation interface


SYNOPSIS

IDL

  module CORBA
    {
    interface Object
      {
      void create_request ( in Context ctx, in Identifier operation,
        in NVList arg_list, inout NamedValue result, out Request req,
        in Flags req_flags ) ;
      } ;
    } ;

C

  #include <orb.h>
  void CORBA_Object_create_request
      ( CORBA_Object o, CORBA_Context ctx, CORBA_Identifier operation,
      CORBA_NVList arg_list, CORBA_NamedValue * result,
      CORBA_Request * req, CORBA_Flags req_flags,
      CORBA_Environment * ev ) ;

C++

  #include <orb.h>
  namespace CORBA
    {
    class Object
      {
        public:
          // two mappings: short form and long form
          void _create_request ( Context_ptr ctx, const char *operation,
            NVList_ptr arg_list, NamedValue_ptr result,
            Request_out request, Flags req_flags ) ;
          void _create_request ( Context_ptr ctx, const char *operation,
            NVList_ptr arg_list, NamedValue_ptr result,
            ExceptionList_ptr, ContextList_ptr,
            Request_out request, Flags req_flags ) ;
      } ;
    } ;

Java

  package org.omg.CORBA ;
  public interface Object
    {
    // two mappings: short form and long form
    Request _create_request ( Context ctx, String operation,
      NVList arg_list, NamedValue result ) ;
    Request _create_request ( Context ctx, String operation,
      NVList arg_list, NamedValue result, ExceptionList exclist,
      ContextList ctxlist ) ;
    }

Perl

(TBS)

Lisp

(TBS)


DESCRIPTION

The CORBA::Object::create_request operation creates a Request pseudo-object for use with the Dynamic Invocation Interface (DII). The DII may be used without pre-compiled skeletons; it allows interfaces to be exploited without knowing the functions in advance.

Once the Request object has been created, CORBA::Request::send or CORBA::Reqest::invoke may be used to make the request to the service object.


PARAMETERS

ctx (in, Context, Object)

The context object for the operation. Encapsulates a list of name/value pairs, where name and value are strings. The information is to propagated to the ORB hosting the service object.

operation (in, Identifier, string)

The name of the operation to be invoked. See Notes, below, regarding implicit operations inherited from CORBA::Object.

arg_list (in, NVList, Object)

A list of arguments, values, and modes (IN, OUT, or INOUT) to be sent to the target when making the invocation. May be the NIL object; see Notes, below.

result (inout, NamedValue, struct)

Storage location for result to be returned from the invocation.

req (out, Request, Object)

The Request object created by this invocation of create_request.

req_flags (in, Flags, unsigned long)

This is a bit map. Only one bit is defined, CORBA::OUT_LIST_MEMORY. If OUT_LIST_MEMORY is set, then arg_list may not be NIL, and any dynamically allocated OUT arguments associated with arg_list will be freed automatically when arg_list is freed. Otherwise, if OUT_LIST_MEMORY is not set, then any dynamically allocated OUT arguments must be freed explicitly.

o

(C mapping only) the target object

ev

(C mapping only) a pointer to the CORBA_Environment


RETURN VALUE

void


EXCEPTIONS

CORBA::BAD_PARAM, with minor code 32

An impermissible implicit operation (inherited from CORBA::Object) was passed in the operation argument.

(standard system exceptions)


NOTES

  1. There are two ways to specify the argument list; an application must choose one or the other, but not both, for any given request.

    The first mechanism is to specify arg_list using this create_request operation.

    The second mechanism is to pass CORBA::NIL for the arg_list, and then use repeated invocations of add_arg on req to specify the arguments.

  2. Of the implicit operations inherited from CORBA::Object, only four are permitted with this DII mechanism: non_existent, is_a, repository_id, and get_interface. In the case of these four implicit operations, the operation parameter must be set to the operation name, prepended with an underscore character. In other words, the four allowable values for implicit operation names are "_non_existent", "_is_a", "_repository_id", and "_get_interface".

  3. (C++ mapping only) The IDL header is named orb.idl. The C++ mapping specification does not mention a specific header name. One might presume the header name should be orb.h. However, some ORB vendors are more imaginative, and use other, different header file names.

  4. (C++ mapping only) The C++ mapping of names may vary, depending on the implementation's support for nested classes and namespaces. The rules are:

        if C++ namespace is supported,
            then map IDL module to C++ namespace
        else if C++ nested classes are supported,
            then map IDL module to a C++ class
        else
            use the C mapping for names

    The C++ synopsis, above, assumes namespace support. For other situations, adjust accordingly.


SEE ALSO

CORBA::Object(3corba)


COPYRIGHT

Copyright 2012 Michael Marking. This document is distributed as part of corbadoc, a documentation-only package with the goal of describing the main CORBA-related definitions from the OMG specifications. This is version corbadoc-0.1.3-prototype, released 2011.12.23. corbadoc is an incomplete work in progress; this is a snapshot release. New releases will be posted at http://www.tatanka.com/software/corbadoc/.

The corbadoc documents, including this one, are licensed under the GNU Free Documentation License, v.1.3.