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
120
121
122
123
124
125
126
127
128
129
130
131
|
#include "ORBInitializer_Registry.h"
#include "PortableInterceptorC.h"
#include "ORB.h"
#include "TAO_Singleton.h"
#include "ORB_Constants.h"
#include "TAO_Singleton_Manager.h"
#include "SystemException.h"
#include "ace/Static_Object_Lock.h"
ACE_RCSID (tao,
ORBInitializer_Registry,
"$Id$")
// ****************************************************************
void
PortableInterceptor::register_orb_initializer (
PortableInterceptor::ORBInitializer_ptr init
ACE_ENV_ARG_DECL)
{
// Using ACE_Static_Object_Lock::instance() precludes
// <register_orb_initializer> from being called within a static
// object CTOR.
ACE_MT (ACE_GUARD (TAO_SYNCH_RECURSIVE_MUTEX,
guard,
*ACE_Static_Object_Lock::instance ()));
// Make sure TAO's singleton manager is initialized.
if (TAO_Singleton_Manager::instance ()->init () == -1)
{
ACE_ERROR ((LM_ERROR,
ACE_TEXT ("(%P|%t) register_orb_initializer: ")
ACE_TEXT ("Unable to pre-initialize TAO\n")));
}
CORBA::ORB::init_orb_globals (ACE_ENV_SINGLE_ARG_PARAMETER);
ACE_CHECK;
// Make sure the following is done after the global ORB
// initialization since we need to have exceptions initialized.
TAO_ORBInitializer_Registry::instance ()->register_orb_initializer (
init
ACE_ENV_ARG_PARAMETER);
}
// ------------------------------------------------------------------
TAO_ORBInitializer_Registry::TAO_ORBInitializer_Registry (void)
: initializers_ ()
{
}
void
TAO_ORBInitializer_Registry::register_orb_initializer (
PortableInterceptor::ORBInitializer_ptr init
ACE_ENV_ARG_DECL)
{
if (!CORBA::is_nil (init))
{
// Increase the length of the ORBInitializer array by one.
const size_t cur_len = this->initializers_.size ();
const size_t new_len = cur_len + 1;
if (this->initializers_.size (new_len) != 0)
ACE_THROW (CORBA::INTERNAL ());
// Add the given ORBInitializer to the sequence.
this->initializers_[cur_len] =
PortableInterceptor::ORBInitializer::_duplicate (init);
}
else
ACE_THROW (CORBA::INV_OBJREF (
CORBA::SystemException::_tao_minor_code (
0,
EINVAL),
CORBA::COMPLETED_NO));
}
void
TAO_ORBInitializer_Registry::pre_init (
PortableInterceptor::ORBInitInfo_ptr info
ACE_ENV_ARG_DECL)
{
const size_t initializer_count = this->initializers_.size ();
for (size_t i = 0; i < initializer_count; ++i)
{
this->initializers_[i]->pre_init (info
ACE_ENV_ARG_PARAMETER);
ACE_CHECK;
}
}
void
TAO_ORBInitializer_Registry::post_init (
PortableInterceptor::ORBInitInfo_ptr info
ACE_ENV_ARG_DECL)
{
const size_t initializer_count = this->initializers_.size ();
for (size_t i = 0; i < initializer_count; ++i)
{
this->initializers_[i]->post_init (info
ACE_ENV_ARG_PARAMETER);
ACE_CHECK;
}
}
TAO_ORBInitializer_Registry *
TAO_ORBInitializer_Registry::instance (void)
{
return
TAO_Singleton<TAO_ORBInitializer_Registry, TAO_SYNCH_MUTEX>::instance ();
}
#if defined (ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION)
template class TAO_Singleton<TAO_ORBInitializer_Registry, TAO_SYNCH_MUTEX>;
template class ACE_Array_Base<PortableInterceptor::ORBInitializer_var>;
#elif defined (ACE_HAS_TEMPLATE_INSTANTIATION_PRAGMA)
#pragma instantiate TAO_Singleton<TAO_ORBInitializer_Registry, TAO_SYNCH_MUTEX>
#pragma instantiate ACE_Array_Base<PortableInterceptor::ORBInitializer_var>
#elif defined (ACE_HAS_EXPLICIT_STATIC_TEMPLATE_MEMBER_INSTANTIATION)
template TAO_Singleton<TAO_ORBInitializer_Registry, TAO_SYNCH_MUTEX> * TAO_Singleton<TAO_ORBInitializer_Registry, TAO_SYNCH_MUTEX>::singleton_;
#endif /* ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION */
|
