TAO_PortableServer: PortableServer Namespace Reference

00021   {
00022     USER_ID,
00023     SYSTEM_ID
00024   };

00021   {
00022     UNIQUE_ID,
00023     MULTIPLE_ID
00024   };

00021   {
00022     IMPLICIT_ACTIVATION,
00023     NO_IMPLICIT_ACTIVATION
00024   };

00021   {
00022     TRANSIENT,
00023     PERSISTENT
00024   };

00029   {
00030     RETAIN,
00031     NON_RETAIN
00032   };

00029   {
00030     ORB_CTRL_MODEL,
00031     SINGLE_THREAD_MODEL
00032 /*    ,MAIN_THREAD_MODEL*/
00033   };

00044   {
00045     // Create space
00046     char * string = CORBA::string_alloc (id.length ());
00047 
00048     // Copy the data
00049     ACE_OS::memcpy (string, id.get_buffer (), id.length ());
00050 
00051     // Null terminate the string
00052     string[id.length ()] = '\0';
00053 
00054     // Return string
00055     return string;
00056   }

00045   {
00046     // Compute resulting wide string's length.
00047     CORBA::ULong string_length =
00048       id.length () / sizeof (CORBA::WChar);
00049 
00050     // Allocate an extra slot if the id's length is not "aligned" on a
00051     // CORBA::WChar.
00052     if (id.length () % sizeof (CORBA::WChar))
00053       string_length++;
00054 
00055     // Create space - note that this method adds + 1 for the '\0'.
00056     CORBA::WChar* string = CORBA::wstring_alloc (string_length);
00057 
00058     // Copy the data
00059     ACE_OS::memcpy (string,
00060                     id.get_buffer (),
00061                     id.length ());
00062 
00063     // Null terminate the string
00064     string[string_length] = '\0';
00065 
00066     // Return string.
00067     return string;
00068   }

00015   {
00016     // Size of string
00017     //
00018     // We DO NOT include the zero terminator, as this is simply an
00019     // artifact of the way strings are stored in C.
00020     //
00021     CORBA::ULong buffer_size = static_cast <CORBA::ULong>
00022                                            (ACE_OS::strlen (string));
00023 
00024     // Create the buffer for the Id
00025     CORBA::Octet *buffer = PortableServer::ObjectId::allocbuf (buffer_size);
00026 
00027     // Copy the contents
00028     ACE_OS::memcpy (buffer, string, buffer_size);
00029 
00030     // Create and return a new ID
00031     PortableServer::ObjectId *id = 0;
00032     ACE_NEW_RETURN (id,
00033                     PortableServer::ObjectId (buffer_size,
00034                                               buffer_size,
00035                                               buffer,
00036                                               1),
00037                     0);
00038 
00039     return id;
00040   }

00015   {
00016     // Size of Id
00017     //
00018     // We DO NOT include the zero terminator, as this is simply an
00019     // artifact of the way strings are stored in C.
00020     //
00021     u_int string_length = ACE_OS::wslen (string);
00022 
00023     CORBA::ULong buffer_size = string_length * sizeof (CORBA::WChar);
00024 
00025     // Create the buffer for the Id
00026     CORBA::Octet *buffer = PortableServer::ObjectId::allocbuf (buffer_size);
00027 
00028     // Copy contents
00029     ACE_OS::memcpy (buffer, string, buffer_size);
00030 
00031     // Create a new ID
00032     PortableServer::ObjectId *id = 0;
00033     ACE_NEW_RETURN (id,
00034                     PortableServer::ObjectId (buffer_size,
00035                                               buffer_size,
00036                                               buffer,
00037                                               1),
00038                     0);
00039 
00040     return id;
00041   }

    &_tao_tc_PortableServer_ObjectId


Classes
interface	AdapterActivator
	AdapterActivator interface. More...
exception	ForwardRequest
interface	IdAssignmentPolicy
interface	IdUniquenessPolicy
interface	ImplicitActivationPolicy
interface	LifespanPolicy
interface	POA
exception	POA::AdapterAlreadyExists
exception	POA::AdapterNonExistent
exception	POA::InvalidPolicy
exception	POA::NoServant
exception	POA::ObjectAlreadyActive
exception	POA::ObjectNotActive
exception	POA::ServantAlreadyActive
exception	POA::ServantNotActive
exception	POA::WrongAdapter
exception	POA::WrongPolicy
interface	POAManager
exception	POAManager::AdapterInactive
interface	POAManagerFactory
exception	POAManagerFactory::ManagerAlreadyExists
interface	Current
exception	Current::NoContext
struct	RefCountServantBase
interface	RequestProcessingPolicy
class	Servant_var
	Provides a type safe counted reference to servants. More...
interface	ServantActivator
interface	ServantLocator
interface	ServantManager
interface	ServantRetentionPolicy
interface	ThreadPolicy
Typedefs
typedef POAManager *	POAManager_ptr
typedef TAO_Objref_Var_T< POAManager >	POAManager_var
typedef POAManagerFactory *	POAManagerFactory_ptr
typedef POA *	POA_ptr
typedef sequence< POA >	POAList
typedef CORBA::OctetSeq	ObjectId
typedef TAO_ServantBase	ServantBase
typedef Servant_var< TAO_ServantBase >	ServantBase_var
typedef TAO_Local_ServantBase	LocalServantBase
typedef TAO_DynamicImplementation	DynamicImplementation
typedef CORBA::OctetSeq_var	ObjectId_var
typedef CORBA::OctetSeq_out	ObjectId_out
typedef TAO_Objref_Var_T< POA >	POA_var
typedef TAO_Objref_Out_T< POA >	POA_out
typedef ServantManager *	ServantManager_ptr
Enumerations
enum	IdAssignmentPolicyValue { USER_ID, SYSTEM_ID }
enum	IdUniquenessPolicyValue { UNIQUE_ID, MULTIPLE_ID }
enum	ImplicitActivationPolicyValue { IMPLICIT_ACTIVATION, NO_IMPLICIT_ACTIVATION }
enum	LifespanPolicyValue { TRANSIENT, PERSISTENT }
enum	RequestProcessingPolicyValue { USE_ACTIVE_OBJECT_MAP_ONLY, USE_DEFAULT_SERVANT, USE_SERVANT_MANAGER }
enum	ServantRetentionPolicyValue { RETAIN, NON_RETAIN }
enum	ThreadPolicyValue { ORB_CTRL_MODEL, SINGLE_THREAD_MODEL }
Functions
PortableServer::ObjectId *	string_to_ObjectId (const char *string)
char *	ObjectId_to_string (const PortableServer::ObjectId &id)
	Utility functions for the other.
PortableServer::ObjectId *	wstring_to_ObjectId (const CORBA::WChar *string)
CORBA::WChar *	ObjectId_to_wstring (const PortableServer::ObjectId &id)
template<class X, class Y> bool	operator== (Servant_var< X > const &x, Servant_var< Y > const &y)
	Compare two Servant_vars for equivalence.
template<class X, class Y> bool	operator!= (Servant_var< X > const &x, Servant_var< Y > const &y)
	Compare two Servant_vars for non-equivalence.
Variables
const CORBA::PolicyType	THREAD_POLICY_ID = 16
const CORBA::PolicyType	LIFESPAN_POLICY_ID = 17
const CORBA::PolicyType	ID_UNIQUENESS_POLICY_ID = 18
const CORBA::PolicyType	ID_ASSIGNMENT_POLICY_ID = 19
const CORBA::PolicyType	IMPLICIT_ACTIVATION_POLICY_ID = 20
const CORBA::PolicyType	SERVANT_RETENTION_POLICY_ID = 21
const CORBA::PolicyType	REQUEST_PROCESSING_POLICY_ID = 22
local interface	POAManager
local interface	POAManagerFactory
local interface	AdapterActivator
local interface	ServantManager
local interface	POA
native	Servant
::CORBA::TypeCode_ptr const	_tc_ObjectId

PortableServer Namespace Reference

Classes

Typedefs

Enumerations

Functions

Variables

Detailed Description

Typedef Documentation

Enumeration Type Documentation

Function Documentation

Variable Documentation