// -*- Mode: C++; -*- // Package : omniORB2 // omniIOR.h Created on: 11/8/99 // Author : Sai Lai Lo (sll) // // Copyright (C) 1999-2000 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 Library General Public // License as published by the Free Software Foundation; either // version 2 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 // Library General Public License for more details. // // You should have received a copy of the GNU Library General Public // License along with this library; if not, write to the Free // Software Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA // 02111-1307, USA // // // Description: // *** PROPRIETORY INTERFACE *** // /* $Log: omniIOR.h,v $ Revision 1.1.4.3 2006/07/18 16:21:24 dgrisby New experimental connection management extension; ORB core support for it. Revision 1.1.4.2 2005/01/06 23:08:09 dgrisby Big merge from omni4_0_develop. Revision 1.1.4.1 2003/03/23 21:04:14 dgrisby Start of omniORB 4.1.x development branch. Revision 1.1.2.13 2003/01/14 11:48:15 dgrisby Remove warnings from gcc -Wshadow. Thanks Pablo Mejia. Revision 1.1.2.12 2002/09/08 21:12:38 dgrisby Properly handle IORs with no usable profiles. Revision 1.1.2.11 2002/01/02 18:13:43 dpg1 Platform fixes/additions. Revision 1.1.2.10 2001/08/15 10:26:08 dpg1 New object table behaviour, correct POA semantics. Revision 1.1.2.9 2001/08/06 15:49:17 sll Added IOP component TAG_OMNIORB_UNIX_TRANS for omniORB specific local transport using the unix domain socket. Revision 1.1.2.8 2001/07/31 16:10:38 sll Added GIOP BiDir support. Revision 1.1.2.7 2001/06/13 20:07:25 sll Minor update to make the ORB compiles with MSVC++. Revision 1.1.2.6 2001/06/11 17:53:23 sll The omniIOR ctor used by genior and corbaloc now has the option to select whether to call interceptors and what set of interceptors to call. Revision 1.1.2.5 2001/05/09 17:00:27 sll addr_selected_profile_index() now returns signed long. Revision 1.1.2.4 2001/04/18 17:50:44 sll Big checkin with the brand new internal APIs. Scoped where appropriate with the omni namespace. Revision 1.1.2.3 2000/11/15 17:06:49 sll Added tcs_c and tcs_w in omniIOR to record what code set convertor to use for this IOR. Added declarations for handlers of the tagged components used by the ORB. Revision 1.1.2.2 2000/10/03 17:37:07 sll Changed omniIOR synchronisation mutex from omni::internalLock to its own mutex. Revision 1.1.2.1 2000/09/27 16:54:08 sll *** empty log message *** */ #ifndef __OMNIIOR_H__ #define __OMNIIOR_H__ #include OMNI_NAMESPACE_BEGIN(omni) class Rope; OMNI_NAMESPACE_END(omni) class omniIORHints { public: const CORBA::PolicyList* policies; inline omniIORHints(const CORBA::PolicyList* p) : policies(p) {} }; class omniIOR { public: /////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////// // Accessor functions for the 2 components of the IOR const char* repositoryID() const { return pd_repositoryID; } const IOP::TaggedProfileList& iopProfiles() const { return pd_iopProfiles; } // index into pd_iopProfiles which has been chosen and decoded _CORBA_Long addr_selected_profile_index() const { return pd_addr_selected_profile_index; } void addr_selected_profile_index(_CORBA_Long index_) { pd_addr_selected_profile_index = index_; } // set and get functions for addr_mode. // The value of addr_mode determines what AddressingDisposition mode // the ORB will use to invoke on the object. The mode is only relevant // for GIOP 1.2 upwards. GIOP::AddressingDisposition addr_mode() const { return pd_addr_mode; } void addr_mode(GIOP::AddressingDisposition m) { pd_addr_mode = m; } /////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////// // Information encoded in the taggedprofilelist may be decoded // into the more accessible forms and stored in an IORInfo. // class IORInfo; IORInfo* getIORInfo() const; // Within IORInfo, additional decoded info can be deposited using // the IORExtraInfo class. Typically this is used by decodeIOR interceptors // to insert extra info into the IOR for later retreival. // class IORExtraInfo { public: IORExtraInfo(const IOP::ComponentId cid) : compid(cid) {} virtual ~IORExtraInfo() {} IOP::ComponentId compid; private: IORExtraInfo(); IORExtraInfo(const IORExtraInfo&); IORExtraInfo& operator=(const IORExtraInfo&); }; // For each unique ComponentId (e.g., TAG_GROUP) one can add // an IORExtraInfo element to the extra_info list. // Each extrainfo element should be constructed by deriving from // this class so that extra members can be held. typedef _CORBA_PseudoValue_Sequence IORExtraInfoList; class IORInfo { public: // GIOP version. const GIOP::Version& version() const { return pd_version; } void version(const GIOP::Version& ver) { pd_version = ver; } // List of address to use _OMNI_NS(giopAddressList)& addresses() { return pd_addresses; } // ORB ID _CORBA_ULong orbType() const { return pd_orb_type; } void orbType(_CORBA_ULong t) { pd_orb_type = t; } // Transmission code set for char and string _OMNI_NS(omniCodeSet::TCS_C)* TCS_C() const { return pd_tcs_c; } void TCS_C(_OMNI_NS(omniCodeSet::TCS_C)* tcs_c) { pd_tcs_c = tcs_c; } // Transmission code set for wchar and wstring _OMNI_NS(omniCodeSet::TCS_W)* TCS_W() const { return pd_tcs_w; } void TCS_W(_OMNI_NS(omniCodeSet::TCS_W)* tcs_w) { pd_tcs_w = tcs_w; } // Extra info list IORExtraInfoList& extraInfo() { return pd_extra_info; } IORInfo(); ~IORInfo(); private: GIOP::Version pd_version; _OMNI_NS(giopAddressList) pd_addresses; _CORBA_ULong pd_orb_type; _OMNI_NS(omniCodeSet::TCS_C)* pd_tcs_c; _OMNI_NS(omniCodeSet::TCS_W)* pd_tcs_w; IORExtraInfoList pd_extra_info; }; public: /////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////// omniIOR(char* repoId, IOP::TaggedProfileList* iop); // Both repoId and iop are consumed by the object. omniIOR(char* repoId, IOP::TaggedProfile* iop, _CORBA_ULong niops, _CORBA_ULong selected_profile_index); // Both repoId and iop are consumed by the object. omniIOR(const char* repoId, const _CORBA_Octet* key, int keysize, const omniIORHints& hints); // Create an IOR for a local object with the given key // Must hold . enum interceptorOption { NoInterceptor, DefaultInterceptors, AllInterceptors }; omniIOR(const char* repoId, const _CORBA_Unbounded_Sequence_Octet& key, const IIOP::Address* addrs, _CORBA_ULong naddrs, GIOP::Version ver, interceptorOption call_interceptors, const IOP::MultipleComponentProfile* tagged_components = 0); ~omniIOR(); void marshalIORAddressingInfo(cdrStream& s) const; // Synchronisation and reference counting: // // The object is reference counted. Call duplcate() to increment the // reference count. Call release() to decrement the reference count. // // The reference count is protected by the mutex omniIOR::lock. // omniIOR* duplicate(); // return a pointer to this object. // Atomic and thread safe. Caller must not hold omniIOR::lock. void release(); // If the reference count is 0, delete is called on the object. // Atomic and thread safe. Caller must not hold omniIOR::lock static _core_attr omni_tracedmutex* lock; public: // ORB internal functions. omniIOR* duplicateNoLock(); // Must hold . Otherwise same semantics as duplicate(). void releaseNoLock(); // Must hold . Otherwise same semantics as release(). /////////////////////////////////////////////////////////////////// // Create a new taggedcomponent slot in the IIOP profile. // The caller can write to the tagged component immediately after this // call. // Use this call only in the encodeIOR interceptors. static IOP::TaggedComponent& newIIOPtaggedComponent(IOP::MultipleComponentProfile&); void decodeIOPprofile(const IIOP::ProfileBody&); // Decode the information in the argument into IORInfo accessible via // getIORInfo(). // Handlers for each of the tagged component used by the ORB static void unmarshal_TAG_ORB_TYPE(const IOP::TaggedComponent&, omniIOR&); static char* dump_TAG_ORB_TYPE(const IOP::TaggedComponent&); //// static void unmarshal_TAG_CODE_SETS(const IOP::TaggedComponent&, omniIOR&); static char* dump_TAG_CODE_SETS(const IOP::TaggedComponent&); static void add_TAG_CODE_SETS(const _OMNI_NS(CONV_FRAME::CodeSetComponentInfo)&); //// static void unmarshal_TAG_ALTERNATE_IIOP_ADDRESS(const IOP::TaggedComponent&, omniIOR&); static char* dump_TAG_ALTERNATE_IIOP_ADDRESS(const IOP::TaggedComponent&); static void add_TAG_ALTERNATE_IIOP_ADDRESS(const IIOP::Address&); //// static void unmarshal_TAG_GROUP(const IOP::TaggedComponent&, omniIOR&); static char* dump_TAG_GROUP(const IOP::TaggedComponent&); //// static void unmarshal_TAG_SSL_SEC_TRANS(const IOP::TaggedComponent&, omniIOR&); static char* dump_TAG_SSL_SEC_TRANS(const IOP::TaggedComponent&); static void add_TAG_SSL_SEC_TRANS(const IIOP::Address&, _CORBA_UShort supports, _CORBA_UShort requires); //// static void unmarshal_TAG_OMNIORB_BIDIR(const IOP::TaggedComponent&, omniIOR&); static char* dump_TAG_OMNIORB_BIDIR(const IOP::TaggedComponent&); static void add_TAG_OMNIORB_BIDIR(const char* sendfrom, omniIOR&); //// static void unmarshal_TAG_OMNIORB_UNIX_TRANS(const IOP::TaggedComponent&, omniIOR&); static char* dump_TAG_OMNIORB_UNIX_TRANS(const IOP::TaggedComponent&); static void add_TAG_OMNIORB_UNIX_TRANS(const char* filename); //// static void unmarshal_TAG_OMNIORB_PERSISTENT_ID(const IOP::TaggedComponent&, omniIOR&); static char* dump_TAG_OMNIORB_PERSISTENT_ID(const IOP::TaggedComponent&); //// static void add_IIOP_ADDRESS(const IIOP::Address&); // Add this address to the IIOP profile. private: _CORBA_String_member pd_repositoryID; IOP::TaggedProfileList_var pd_iopProfiles; _CORBA_Long pd_addr_selected_profile_index; GIOP::AddressingDisposition pd_addr_mode; IORInfo* pd_iorInfo; int pd_refCount; // Protected by omniIOR(); omniIOR(const omniIOR&); omniIOR& operator=(const omniIOR&); }; class omniIOR_var { public: inline omniIOR_var() : pd_ior(0) {} inline omniIOR_var(omniIOR* ior) : pd_ior(ior) {} inline omniIOR* _retn() { omniIOR* p = pd_ior; pd_ior = 0; return p; } inline operator omniIOR* () const { return pd_ior; } inline omniIOR* operator->() const { return pd_ior; } inline omniIOR_var& operator=(omniIOR* p) { if (pd_ior) pd_ior->release(); pd_ior = p; return *this; } inline ~omniIOR_var() { if (pd_ior) pd_ior->release(); } private: omniIOR* pd_ior; }; #endif // __OMNIIOR_H__