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
|
// **********************************************************************
//
// Copyright (c) 2003-2017 ZeroC, Inc. All rights reserved.
//
// This copy of Ice is licensed to you under the terms described in the
// ICE_LICENSE file included in this distribution.
//
// **********************************************************************
#include <Logger.h>
#include <Util.h>
#include <Ice/Initialize.h>
using namespace std;
using namespace IceRuby;
static VALUE _loggerClass;
extern "C"
void
IceRuby_Logger_free(Ice::LoggerPtr* p)
{
assert(p);
delete p;
}
VALUE
IceRuby::createLogger(const Ice::LoggerPtr& p)
{
return Data_Wrap_Struct(_loggerClass, 0, IceRuby_Logger_free, new Ice::LoggerPtr(p));
}
extern "C"
VALUE
IceRuby_Logger_print(VALUE self, VALUE message)
{
ICE_RUBY_TRY
{
Ice::LoggerPtr* p = reinterpret_cast<Ice::LoggerPtr*>(DATA_PTR(self));
assert(p);
string msg = getString(message);
(*p)->print(msg);
}
ICE_RUBY_CATCH
return Qnil;
}
extern "C"
VALUE
IceRuby_Logger_trace(VALUE self, VALUE category, VALUE message)
{
ICE_RUBY_TRY
{
Ice::LoggerPtr* p = reinterpret_cast<Ice::LoggerPtr*>(DATA_PTR(self));
assert(p);
string cat = getString(category);
string msg = getString(message);
(*p)->trace(cat, msg);
}
ICE_RUBY_CATCH
return Qnil;
}
extern "C"
VALUE
IceRuby_Logger_warning(VALUE self, VALUE message)
{
ICE_RUBY_TRY
{
Ice::LoggerPtr* p = reinterpret_cast<Ice::LoggerPtr*>(DATA_PTR(self));
assert(p);
string msg = getString(message);
(*p)->warning(msg);
}
ICE_RUBY_CATCH
return Qnil;
}
extern "C"
VALUE
IceRuby_Logger_error(VALUE self, VALUE message)
{
ICE_RUBY_TRY
{
Ice::LoggerPtr* p = reinterpret_cast<Ice::LoggerPtr*>(DATA_PTR(self));
assert(p);
string msg = getString(message);
(*p)->error(msg);
}
ICE_RUBY_CATCH
return Qnil;
}
extern "C"
VALUE
IceRuby_Logger_cloneWithPrefix(VALUE self, VALUE prefix)
{
ICE_RUBY_TRY
{
Ice::LoggerPtr* p = reinterpret_cast<Ice::LoggerPtr*>(DATA_PTR(self));
assert(p);
string pfx = getString(prefix);
Ice::LoggerPtr clone = (*p)->cloneWithPrefix(pfx);
return createLogger(clone);
}
ICE_RUBY_CATCH
return Qnil;
}
extern "C"
VALUE
IceRuby_getProcessLogger()
{
ICE_RUBY_TRY
{
Ice::LoggerPtr logger = Ice::getProcessLogger();
return createLogger(logger);
}
ICE_RUBY_CATCH
return Qnil;
}
bool
IceRuby::initLogger(VALUE iceModule)
{
//
// Logger.
//
_loggerClass = rb_define_class_under(iceModule, "LoggerI", rb_cObject);
//
// Instance methods.
//
rb_define_method(_loggerClass, "print", CAST_METHOD(IceRuby_Logger_print), 1);
rb_define_method(_loggerClass, "trace", CAST_METHOD(IceRuby_Logger_trace), 2);
rb_define_method(_loggerClass, "warning", CAST_METHOD(IceRuby_Logger_warning), 1);
rb_define_method(_loggerClass, "error", CAST_METHOD(IceRuby_Logger_error), 1);
rb_define_method(_loggerClass, "cloneWithPrefix", CAST_METHOD(IceRuby_Logger_cloneWithPrefix), 1);
//
// Global methods.
//
rb_define_module_function(iceModule, "getProcessLogger", CAST_METHOD(IceRuby_getProcessLogger), 0);
return true;
}
|
