NAME

CORBA::Object::hash - (operation) compute a hash value on an object reference


SYNOPSIS

IDL

  module CORBA
    {
    interface Object
      {
      unsigned long hash ( in unsigned long maximum ) ;
      } ;
    } ;

C

  #include <orb.h>
  CORBA_unsigned_long CORBA_Object_hash
      ( CORBA_Object o,
      CORBA_unsigned_long maximum,
      CORBA_Environment * ev ) ;

C++

  #include <orb.h>
  namespace CORBA
    {
    class Object
      {
        public:
          ULong _hash ( ULong maximum ) ;
      } ;
    } ;

Java

  package org.omg.CORBA ;
  public interface Object
    {
    int _hash ( int maximum ) ;
    }

Perl

(TBS)

Lisp

(TBS)


DESCRIPTION

The CORBA::Object::hash operation computes a hash value on an object reference. The computed value ranges from zero to maximum.

This function enables applications to construct hash tables of object references, as might be needed in databases, routers, and other applications needing to maintain large tables of objects. Because object references are opaque to applications, it is not otherwise possible to calculate such hash code values.


PARAMETERS

o

(C mapping only) the target object

ev

(C mapping only) a pointer to the CORBA_Environment


RETURN VALUE

The computed hash value for the object reference.


EXCEPTIONS

(standard system exceptions)


NOTES

  1. The specification does not indicate whether local policies are incorporated into the hash value computation. In contrast, some functions (see, for example, CORBA::Object::is_equivalent) explicitly exclude local policies from their determinations. That is, it is not clear whether two references to the same object, but with different policies, ought to hash to the same or to different values.

  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.