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
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
|
// -*- C++ -*-
//=============================================================================
/**
* @file TAO_Singleton_Manager.h
*
* $Id$
*
* Header file for the TAO-specific Singleton Manager. Based
* entirely on ace/Object_Manager.{h,i,cpp}.
*
*
* @author Ossama Othman <ossama@uci.edu>
*/
//=============================================================================
#ifndef TAO_SINGLETON_MANAGER_H
#define TAO_SINGLETON_MANAGER_H
#include "ace/pre.h"
#include "tao/TAO_Export.h"
#include "tao/orbconf.h"
#if !defined (ACE_LACKS_PRAGMA_ONCE)
# pragma once
#endif /* ACE_LACKS_PRAGMA_ONCE */
#include "ace/OS.h"
// Adapter for cleanup, used to register cleanup function with the
// ACE_Object_Manager.
extern "C"
void
TAO_Singleton_Manager_cleanup_destroyer (void *, void *);
/**
* @class TAO_Singleton_Manager
*
* @brief Manager for TAO library services and singleton cleanup.
*
* The <TAO_Singleton_Manager> is basically simplified version of
* the ACE_Object_Manager. It is designed specifically to
* manage singletons created by TAO. For example, Singleton
* instances created by TAO will be automatically registered
* with the Singleton instance of this Singleton Manager.
* This class is necessary to ensure that TAO-specific
* Singletons are centrally isolated. The idea is that
* destruction of the instance of the <TAO_Singleton_Manager>
* triggers destruction of all objects/services registered with
* it.
*/
class TAO_Export TAO_Singleton_Manager : public ACE_Object_Manager_Base
{
friend void TAO_Singleton_Manager_cleanup_destroyer (void *, void *);
public:
/// Explicitly initialize.
virtual int init (void);
/**
* Explicitly initialize the TAO_Singleton_Manager, in addition to
* explicitly registering (or not registering) with the
* ACE_Object_Manager.
*/
int init (int register_with_object_manager);
/// Explicitly destroy.
virtual int fini (void);
/**
* Returns 1 before the <TAO_Singleton_Manager> has been
* constructed. See <ACE_Object_Manager::starting_up> for more
* information.
*/
static int starting_up (void);
/// Returns 1 after the <TAO_Singleton_Manager> has been destroyed.
/// See <ACE_Object_Manager::shutting_down> for more information.
static int shutting_down (void);
enum Preallocated_Object
{
# if defined (ACE_MT_SAFE) && (ACE_MT_SAFE != 0)
// @@ No MT-specific preallocated objects (yet). Remove the
// below dummy enum once a preallocated object is added.
TAO_EMPTY_PREALLOCATED_OBJECT,
# else
// Without ACE_MT_SAFE, There are no preallocated objects. Make
// sure that the preallocated_array size is at least one by
// declaring this dummy . . .
TAO_EMPTY_PREALLOCATED_OBJECT,
# endif /* ACE_MT_SAFE */
TAO_PREALLOCATED_OBJECTS // This enum value must be last!
};
// Unique identifiers for preallocated objects.
/// Accesses a default signal set used, for example, in
/// <ACE_Sig_Guard> methods.
static sigset_t *default_mask (void);
/// Returns the current thread hook for the process.
static ACE_Thread_Hook *thread_hook (void);
/// Returns the existing thread hook and assign a <new_thread_hook>.
static ACE_Thread_Hook *thread_hook (ACE_Thread_Hook *new_thread_hook);
/// Accessor to singleton instance.
static TAO_Singleton_Manager *instance (void);
/**
* Register an ACE_Cleanup object for cleanup at process
* termination. The object is deleted via the
* <ace_cleanup_destroyer>. If you need more flexiblity, see the
* <other at_exit> method below. For OS's that do not have
* processes, cleanup takes place at the end of <main>. Returns 0
* on success. On failure, returns -1 and sets errno to: EAGAIN if
* shutting down, ENOMEM if insufficient virtual memory, or EEXIST
* if the object (or array) had already been registered.
*/
static int at_exit (ACE_Cleanup *object, void *param = 0);
/**
* Register an object (or array) for cleanup at process termination.
* "cleanup_hook" points to a (global, or static member) function
* that is called for the object or array when it to be destroyed.
* It may perform any necessary cleanup specific for that object or
* its class. "param" is passed as the second parameter to the
* "cleanup_hook" function; the first parameter is the object (or
* array) to be destroyed. "cleanup_hook", for example, may delete
* the object (or array). For OS's that do not have processes, this
* function is the same as <at_thread_exit>. Returns 0 on success.
* On failure, returns -1 and sets errno to: EAGAIN if shutting
* down, ENOMEM if insufficient virtual memory, or EEXIST if the
* object (or array) had already been registered.
*/
static int at_exit (void *object,
ACE_CLEANUP_FUNC cleanup_hook,
void *param);
private:
// Force allocation on the heap.
TAO_Singleton_Manager (void);
~TAO_Singleton_Manager (void);
// Disallow copying by not implementing the following . . .
TAO_Singleton_Manager (const TAO_Singleton_Manager &);
TAO_Singleton_Manager &operator= (const TAO_Singleton_Manager &);
/// Register an object or array for deletion at program termination.
/// See description of static version above for return values.
int at_exit_i (void *object, ACE_CLEANUP_FUNC cleanup_hook, void *param);
private:
/// Singleton instance pointer.
static TAO_Singleton_Manager *instance_;
/// Table of preallocated objects.
static void *preallocated_object[TAO_PREALLOCATED_OBJECTS];
/// Default signal set used, for example, in ACE_Sig_Guard.
sigset_t *default_mask_;
/// Thread hook that's used by this process.
ACE_Thread_Hook *thread_hook_;
/// For at_exit support.
ACE_OS_Exit_Info exit_info_;
/// Indicates if TAO_Singleton_Manager is registered with the
/// ACE_Object_Manager.
int registered_with_object_manager_;
#if defined (ACE_MT_SAFE) && (ACE_MT_SAFE != 0)
/// Lock that is used to guard internal structures.
TAO_SYNCH_RECURSIVE_MUTEX *internal_lock_;
#endif /* ACE_MT_SAFE */
};
#if defined (__ACE_INLINE__)
# include "tao/TAO_Singleton_Manager.inl"
#endif /* __ACE_INLINE__ */
#include "ace/post.h"
#endif /* TAO_SINGLETON_MANAGER_H */
|
