/usr/include/omniORB4/omniORBcompat.h is in libomniorb4-dev 4.2.2-0.8.
This file is owned by root:root, with mode 0o644.
The actual contents of the file can be viewed below.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 | // -*- Mode: C++; -*-
// Package : omniORB
// omniORBcompat.h Created on: 16/08/2001
// Author : Sai Lai Lo (sll)
//
// Copyright (C) 2001 AT&T Laboratories Cambridge
//
// This file is part of the omniORB library
//
// The omniORB library is free software; you can redistribute it and/or
// modify it under the terms of the GNU Lesser General Public
// License as published by the Free Software Foundation; either
// version 2.1 of the License, or (at your option) any later version.
//
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
// Lesser General Public License for more details.
//
// You should have received a copy of the GNU Lesser General Public
// License along with this library. If not, see http://www.gnu.org/licenses/
//
//
// Description:
// The following API is only for omniORB 2.x compatibility. Do
// not use for new code.
#ifndef __OMNIORBCOMPAT_H__
#define __OMNIORBCOMPAT_H__
#ifndef _INCLUDE_OMNIORBCOMPAT_
#error "omniORBcompat.h must be included from omniORB.h"
#endif
////////////////////////////////////////////////////////////////////////
// //
// This section is only for omniORB 2.x compatibility. Do not use for //
// new code. //
// //
// objectKey is a data type that uniquely identify each object //
// implementation in the same address space. Its actual //
// implmentation is not public. The data type should only //
// be processed in an application by the following utility //
// functions. //
// //
// //
typedef omniOrbBoaKey objectKey; //
// //
// generateNewKey() //
// generate a new key. The key is guaranteed to be temporally //
// unique. On OSs that provide unique process IDs, e.g. unices, //
// the key is guaranteed to be unique among all keys ever generated //
// on the same machine. //
_CORBA_MODULE_FN void generateNewKey(objectKey &k); //
// //
// Return a fixed key value that always hash to 0. //
_CORBA_MODULE_FN objectKey nullkey(); //
// //
// Return non-zero if the keys are the same //
_CORBA_MODULE_OP int operator==(const objectKey &k1, //
const objectKey &k2); //
// //
// Return non-zero if the keys are different //
_CORBA_MODULE_OP int operator!=(const objectKey &k1, //
const objectKey &k2); //
// //
// //
typedef _CORBA_Unbounded_Sequence_Octet seqOctets; //
// Convert a key to a sequence of octets. //
_CORBA_MODULE_FN seqOctets* keyToOctetSequence(const objectKey &k1); //
// //
// Convert a sequence of octets back to an object key. //
// This function may throw a CORBA::MARSHAL exception if the sequence //
// is not an object key. //
_CORBA_MODULE_FN objectKey octetSequenceToKey(const seqOctets& seq); //
////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////
// //
// This section is only for omniORB 2.x compatibility. Do not use for //
// new code. //
// //
// An application can register a handler for loading objects //
// dynamically. The handler should have the signature: //
// //
// omniORB::loader::mapKeyToObject_t //
// //
// When the ORB cannot locate the target object in this address space,//
// it calls the handler with the object key of the target. //
// The handler is expected to instantiate the object, either in //
// this address space or in another address space, and returns the //
// object reference to the newly instantiated object. The ORB will //
// then reply with a LOCATION_FORWARD message to instruct the client //
// to retry using the object reference returned by the handler. //
// When the handler returns, the ORB assumes ownership of the //
// returned value. It will call CORBA::release() on the returned //
// value when it has finished with it. //
// //
// The handler may be called concurrently by multi-threads. Hence it //
// must be thread-safe. //
// //
// If the handler cannot load the target object, it should return //
// CORBA::Object::_nil(). The object will be treated as non-existing. //
// //
// The application registers the handler with the ORB at runtime //
// using omniORB::loader::set(). This function is not thread-safe. //
// Calling this function again will replace the old handler with //
// the new one. //
// //
class loader { //
public: //
typedef CORBA::Object_ptr (*mapKeyToObject_t) ( //
const objectKey& key); //
//
static void set(mapKeyToObject_t NewKeyToObject); //
}; //
////////////////////////////////////////////////////////////////////////
#endif // __OMNIORBCOMPAT_H__
|