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
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
|
// $Id$
#include "orbsvcs/LoggerC.h"
#include "orbsvcs/Log/Logger_i.h"
#include "ace/ACE.h"
#include "ace/INET_Addr.h"
#include "ace/Log_Record.h"
ACE_RCSID(Log, Logger_i, "$Id$")
#if defined (ACE_HAS_TEMPLATE_SPECIALIZATION)
#define TAO_Logger_Hash \
ACE_Hash_Map_Manager<ACE_CString, Logger_i *, ACE_Null_Mutex>
u_long
TAO_Logger_Hash::hash (const ACE_CString &ext_id)
{
return ACE::hash_pjw (ext_id.fast_rep ());
}
#endif /* ACE_HAS_TEMPLATE_SPECIALIZATION */
Logger_Factory_i::Logger_Factory_i (void)
{
}
Logger_Factory_i::~Logger_Factory_i (void)
{
}
Logger_ptr
Logger_Factory_i::make_logger (const char *name,
CORBA::Environment &TAO_IN_ENV)
{
Logger_i *result;
// If name is already in the map, <find> will assign <result> to the
// appropriate value
if (hash_map_.find (name, result) != 0)
{
if (TAO_debug_level > 0)
ACE_DEBUG ((LM_DEBUG,
"\nMaking a new logger"));
// This attempts to create a new Logger_i and throws an
// exception and returns a null value if it fails
ACE_NEW_THROW_EX (result,
Logger_i (name),
CORBA::NO_MEMORY ());
ACE_CHECK_RETURN (Logger::_nil ());
}
// Enter the new logger into the hash map. Check if the <bind>
// fails and if so, throw an UNKNOWN exception. <result> may be
// valid, but since it would not be properly bound, its behavior my
// be off, so delete it to be safe.
if (hash_map_.bind (name, result) == -1)
{
delete result;
TAO_THROW_RETURN (CORBA::UNKNOWN (),
Logger::_nil ());
}
else
// Logger of name <name> already bound. <result> is set
// appropriately by <find>. So do nothing.
if (TAO_debug_level > 0)
ACE_DEBUG ((LM_DEBUG,
"\nLogger name already bound"));
// <_this> is an performance hit here, but apparently if the object
// is already registered with the POA, it will ignore the second
// registration attempt.
// @@ Matt, this code doesn't seem right. Can you please check with
// Irfan and Carlos about whether this is the right thing to do?
return result->_this (TAO_IN_ENV);
}
Logger_i::Logger_i (const char *name)
: name_ (ACE_OS::strdup (name)),
verbosity_level_ (Logger::VERBOSE)
{
// Do nothing
}
Logger_i::~Logger_i (void)
{
ACE_OS::free (this->name_);
}
ACE_Log_Priority
Logger_i::priority_conversion (Logger::Log_Priority priority)
{
if (priority == Logger::LM_MAX)
return LM_MAX;
else
{
int pval = ACE_static_cast (int, priority);
return ACE_static_cast (ACE_Log_Priority,
1 << pval);
// (1 << pval) == 2^pval. <ACE_Log_Priority> are powers of 2.
}
}
u_long
Logger_i::verbosity_conversion (Logger::Verbosity_Level verbosity_level)
{
// This isn't very elegant, but it's because there's no simple
// mapping from <Logger::Verbosity_Level>'s to the verbosity flags
// specified in <ace/Log_Msg.h>
switch (verbosity_level)
{
case Logger::SILENT:
return 64;
case Logger::VERBOSE_LITE:
return 32;
default:
case Logger::VERBOSE:
return 16;
}
}
void
Logger_i::log (const Logger::Log_Record &log_rec,
CORBA::Environment &TAO_IN_ENV)
{
this->logv (log_rec, verbosity_level_, TAO_IN_ENV);
}
void
Logger_i::log2 (const Logger::Log_Record &log_rec,
CORBA::Environment &TAO_IN_ENV)
{
this->logv (log_rec, verbosity_level_, TAO_IN_ENV);
}
void
Logger_i::logv2 (const Logger::Log_Record &log_rec,
Logger::Verbosity_Level verbosity,
CORBA::Environment &TAO_IN_ENV)
{
this->logv (log_rec, verbosity, TAO_IN_ENV);
}
void
Logger_i::logv (const Logger::Log_Record &log_rec,
Logger::Verbosity_Level verbosity,
CORBA::Environment &)
{
// Create an <ACE_Log_Record> to leverage existing logging
// code. Since Logger::Log_Priority enum tags don't cleanly map to
// ACE_Log_Priority tags, <priority_conversion> is used to coerce
// the mapping.
ACE_Log_Record rec (this->priority_conversion (log_rec.type),
ACE_Time_Value (log_rec.time),
log_rec.app_id);
// Create a temporary buffer for manipulating the logging message,
// adding additional space for formatting characters..
ASYS_TCHAR msgbuf [ACE_MAXLOGMSGLEN + 4];
// Format the message for proper display.
ACE_OS::strcpy (msgbuf, "::");
// Copy the message data into the temporary buffer
ACE_OS::strncat (msgbuf,
log_rec.msg_data,
ACE_MAXLOGMSGLEN);
// Set <ACE_Log_Record.msg_data> to the value stored in <msgbuf>.
rec.msg_data (msgbuf);
CORBA::Long addr = log_rec.host_addr;
// The constructor for <ACE_INET_Addr> requires a port number, which
// is not relevant in this context, so we give it 0.
ACE_INET_Addr addy (ACE_static_cast (u_short, 0),
ACE_static_cast (ACE_UINT32,
addr));
// Create a buffer and fill it with the host name of the logger
ASYS_TCHAR namebuf[MAXHOSTNAMELEN + 1];
ACE_OS::strncpy (namebuf, addy.get_host_addr (), MAXHOSTNAMELEN);
u_long verb_level = this->verbosity_conversion (verbosity);
rec.print (namebuf,
verb_level,
stderr);
// Print out the logging message to stderr with the given level of
// verbosity
}
Logger::Verbosity_Level
Logger_i::verbosity (void) const
{
return verbosity_level_;
}
void
Logger_i::verbosity (Logger::Verbosity_Level level, CORBA::Environment &env)
{
ACE_UNUSED_ARG (env);
verbosity_level_ = level;
}
#if defined (ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION)
template class ACE_Hash_Map_Entry<ACE_CString, Logger_i *>;
template class ACE_Hash_Map_Manager<ACE_CString, Logger_i *, ACE_Null_Mutex>;
template class ACE_Hash_Map_Manager_Ex<ACE_CString, Logger_i *, ACE_Hash<ACE_CString>, ACE_Equal_To<ACE_CString>, ACE_Null_Mutex>;
template class ACE_Hash_Map_Iterator_Base_Ex<ACE_CString, Logger_i *, ACE_Hash<ACE_CString>, ACE_Equal_To<ACE_CString>, ACE_Null_Mutex>;
template class ACE_Hash_Map_Iterator<ACE_CString, Logger_i *, ACE_Null_Mutex>;
template class ACE_Hash_Map_Iterator_Ex<ACE_CString, Logger_i *, ACE_Hash<ACE_CString>, ACE_Equal_To<ACE_CString>, ACE_Null_Mutex>;
template class ACE_Hash_Map_Reverse_Iterator<ACE_CString, Logger_i *, ACE_Null_Mutex>;
template class ACE_Hash_Map_Reverse_Iterator_Ex<ACE_CString, Logger_i *, ACE_Hash<ACE_CString>, ACE_Equal_To<ACE_CString>, ACE_Null_Mutex>;
#elif defined(ACE_HAS_TEMPLATE_INSTANTIATION_PRAGMA)
#pragma instantiate ACE_Hash_Map_Entry<ACE_CString, Logger_i *>
#pragma instantiate ACE_Hash_Map_Manager<ACE_CString, Logger_i *, ACE_Null_Mutex>
#pragma instantiate ACE_Hash_Map_Manager_Ex<ACE_CString, Logger_i *, ACE_Hash<ACE_CString>, ACE_Equal_To<ACE_CString>, ACE_Null_Mutex>
#pragma instantiate ACE_Hash_Map_Iterator_Base_Ex<ACE_CString, Logger_i *, ACE_Hash<ACE_CString>, ACE_Equal_To<ACE_CString>, ACE_Null_Mutex>
#pragma instantiate ACE_Hash_Map_Iterator<ACE_CString, Logger_i *, ACE_Null_Mutex>
#pragma instantiate ACE_Hash_Map_Iterator_Ex<ACE_CString, Logger_i *, ACE_Hash<ACE_CString>, ACE_Equal_To<ACE_CString>, ACE_Null_Mutex>
#pragma instantiate ACE_Hash_Map_Reverse_Iterator<ACE_CString, Logger_i *, ACE_Null_Mutex>
#pragma instantiate ACE_Hash_Map_Reverse_Iterator_Ex<ACE_CString, Logger_i *, ACE_Hash<ACE_CString>, ACE_Equal_To<ACE_CString>, ACE_Null_Mutex>
#endif /* ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION */
|
