NAME

CORBA::Object::get_domain_managers - (operation) determine whether two different object references are equivalent


SYNOPSIS

IDL

  module CORBA
    {
    typedef sequence <DomainManager> DomainManagersList ;
    interface Object
      {
      DomainManagersList get_domain_managers ( ) ;
      } ;
    } ;

C

  #include <orb.h>
  typedef struct
      {
      CORBA_unsigned_long              _maximum ;
      CORBA_unsigned_long              _length ;
      CORBA_DomainManager              _buffer ;
      }
      CORBA_DomainManagersList ;
  CORBA_DomainManagersList * CORBA_Object_get_domain_managers
      ( CORBA_Object o,
      CORBA_Environment * ev ) ;

C++

  #include <orb.h>
  namespace CORBA
    {
    class DomainManagerList
      {
        // mapped from sequence<DomainManager> ...
      } ;
    class Object
      {
        public:
          DomainManagerList * _get_domain_managers ( ) ;
      } ;
    } ;

Java

  package org.omg.CORBA ;
  public interface Object
    {
    DomainManager [] _get_domain_managers ( ) ;
    }

Perl

(TBS)

Lisp

(TBS)


DESCRIPTION

The CORBA::Object::get_domain_managers operation is used to determine whether two object references (that of the target object, and that of the other_object) are equivalent. In other words, do they refer to the same object?

The determination of equivalence can be time-consuming and can use extensive resources. Therefore, an ORB is not required to exhaust all mechanisms to answer the question. In fact, an ORB may simply return FALSE without contacting remote ORBs or doing other things to determine equivalence. Therefore, when get_domain_managers returns FALSE, the application must not assume that the objects are not equivalent.

On the other hand, a return value of TRUE is a definitive indication that both references point to the same object.


PARAMETERS

o

(C mapping only) the target object

ev

(C mapping only) a pointer to the CORBA_Environment


RETURN VALUE

The list of immediately enclosing domain managers of the target object. There is always at least one domain manager in the list (because, by default, a domain manager is associated with each created object).


EXCEPTIONS

(standard system exceptions)


NOTES

  1. This operation may involve contacting the ORB on which the object's implementation is hosted.

  2. (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.

  3. (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.