← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to drizzled/plugin/logging.cc

  • Committer: Brian Aker
  • Date: 2010-10-28 17:12:01 UTC
  • mfrom: (1887.1.3 merge)
  • Revision ID: brian@tangent.org-20101028171201-baj6l1bnntn1s4ad
Merge in POTFILES changes.

Show diffs side-by-side

added added

removed removed

Lines of Context:
drizzled/plugin/logging.cc
1
1
/* -*- mode: c++; c-basic-offset: 2; indent-tabs-mode: nil; -*-
2
2
 *  vim:expandtab:shiftwidth=2:tabstop=2:smarttab:
3
3
 *
4
 
 *  Copyright (C) 2008 Sun Microsystems, Inc.
 
4
 *  Copyright (C) 2008 Sun Microsystems
5
5
 *
6
6
 *  This program is free software; you can redistribute it and/or modify
7
7
 *  it under the terms of the GNU General Public License as published by
27
27
 
28
28
class Session;
29
29
 
 
30
using namespace std;
 
31
 
30
32
namespace drizzled
31
33
{
32
34
 
33
 
std::vector<plugin::Logging *> all_loggers;
 
35
vector<plugin::Logging *> all_loggers;
34
36
 
35
37
 
36
38
bool plugin::Logging::addPlugin(plugin::Logging *handler)
43
45
void plugin::Logging::removePlugin(plugin::Logging *handler)
44
46
{
45
47
  if (handler != NULL)
46
 
    all_loggers.erase(std::find(all_loggers.begin(), all_loggers.end(), handler));
 
48
    all_loggers.erase(find(all_loggers.begin(), all_loggers.end(), handler));
47
49
}
48
50
 
49
51
 
50
 
class PreIterate : public std::unary_function<plugin::Logging *, bool>
 
52
class PreIterate : public unary_function<plugin::Logging *, bool>
51
53
{
52
54
  Session *session;
53
55
public:
54
56
  PreIterate(Session *session_arg) :
55
 
    std::unary_function<plugin::Logging *, bool>(),
 
57
    unary_function<plugin::Logging *, bool>(),
56
58
    session(session_arg) {}
57
59
 
58
60
  inline result_type operator()(argument_type handler)
61
63
    {
62
64
      /* TRANSLATORS: The leading word "logging" is the name
63
65
         of the plugin api, and so should not be translated. */
64
 
      errmsg_printf(error::ERROR,
 
66
      errmsg_printf(ERRMSG_LVL_ERROR,
65
67
                    _("logging '%s' pre() failed"),
66
68
                    handler->getName().c_str());
67
69
      return true;
71
73
};
72
74
 
73
75
 
74
 
class PostIterate : public std::unary_function<plugin::Logging *, bool>
 
76
class PostIterate : public unary_function<plugin::Logging *, bool>
75
77
{
76
78
  Session *session;
77
79
public:
78
80
  PostIterate(Session *session_arg) :
79
 
    std::unary_function<plugin::Logging *, bool>(),
 
81
    unary_function<plugin::Logging *, bool>(),
80
82
    session(session_arg) {}
81
83
 
82
84
  /* This gets called once for each loaded logging plugin */
86
88
    {
87
89
      /* TRANSLATORS: The leading word "logging" is the name
88
90
         of the plugin api, and so should not be translated. */
89
 
      errmsg_printf(error::ERROR,
 
91
      errmsg_printf(ERRMSG_LVL_ERROR,
90
92
                    _("logging '%s' post() failed"),
91
93
                    handler->getName().c_str());
92
94
      return true;
95
97
  }
96
98
};
97
99
 
98
 
class PostEndIterate : public std::unary_function<plugin::Logging *, bool>
 
100
class PostEndIterate : public unary_function<plugin::Logging *, bool>
99
101
{
100
102
  Session *session;
101
103
public:
102
104
  PostEndIterate(Session *session_arg) :
103
 
    std::unary_function<plugin::Logging *, bool>(),
 
105
    unary_function<plugin::Logging *, bool>(),
104
106
    session(session_arg) {}
105
107
 
106
108
  /* This gets called once for each loaded logging plugin */
110
112
    {
111
113
      /* TRANSLATORS: The leading word "logging" is the name
112
114
         of the plugin api, and so should not be translated. */
113
 
      errmsg_printf(error::ERROR,
 
115
      errmsg_printf(ERRMSG_LVL_ERROR,
114
116
                    _("logging '%s' postEnd() failed"),
115
117
                    handler->getName().c_str());
116
118
      return true;
119
121
  }
120
122
};
121
123
 
122
 
class ResetIterate : public std::unary_function<plugin::Logging *, bool>
123
 
{
124
 
  Session *session;
125
 
public:
126
 
  ResetIterate(Session *session_arg) :
127
 
    std::unary_function<plugin::Logging *, bool>(),
128
 
    session(session_arg) {}
129
 
 
130
 
  inline result_type operator()(argument_type handler)
131
 
  {
132
 
    if (handler->resetGlobalScoreboard())
133
 
    {
134
 
      /* TRANSLATORS: The leading word "logging" is the name
135
 
         of the plugin api, and so should not be translated. */
136
 
      errmsg_printf(error::ERROR,
137
 
                    _("logging '%s' resetCurrentScoreboard() failed"),
138
 
                    handler->getName().c_str());
139
 
      return true;
140
 
    }
141
 
    return false;
142
 
  }
143
 
};
144
 
 
145
 
 
146
124
/* This is the Logging::preDo entry point.
147
125
   This gets called by the rest of the Drizzle server code */
148
126
bool plugin::Logging::preDo(Session *session)
149
127
{
150
128
  /* Use find_if instead of foreach so that we can collect return codes */
151
 
  std::vector<plugin::Logging *>::iterator iter=
152
 
    std::find_if(all_loggers.begin(), all_loggers.end(),
153
 
                 PreIterate(session)); 
 
129
  vector<plugin::Logging *>::iterator iter=
 
130
    find_if(all_loggers.begin(), all_loggers.end(),
 
131
            PreIterate(session)); 
154
132
  /* If iter is == end() here, that means that all of the plugins returned
155
133
   * false, which in this case means they all succeeded. Since we want to 
156
134
   * return false on success, we return the value of the two being != 
163
141
bool plugin::Logging::postDo(Session *session)
164
142
{
165
143
  /* Use find_if instead of foreach so that we can collect return codes */
166
 
  std::vector<plugin::Logging *>::iterator iter=
167
 
    std::find_if(all_loggers.begin(), all_loggers.end(),
168
 
                 PostIterate(session)); 
 
144
  vector<plugin::Logging *>::iterator iter=
 
145
    find_if(all_loggers.begin(), all_loggers.end(),
 
146
            PostIterate(session)); 
169
147
  /* If iter is == end() here, that means that all of the plugins returned
170
148
   * false, which in this case means they all succeeded. Since we want to 
171
149
   * return false on success, we return the value of the two being != 
177
155
bool plugin::Logging::postEndDo(Session *session)
178
156
{
179
157
  /* Use find_if instead of foreach so that we can collect return codes */
180
 
  std::vector<plugin::Logging *>::iterator iter=
181
 
    std::find_if(all_loggers.begin(), all_loggers.end(),
182
 
                 PostEndIterate(session));
 
158
  vector<plugin::Logging *>::iterator iter=
 
159
    find_if(all_loggers.begin(), all_loggers.end(),
 
160
            PostEndIterate(session));
183
161
  /* If iter is == end() here, that means that all of the plugins returned
184
162
   * false, which in this case means they all succeeded. Since we want to
185
163
   * return false on success, we return the value of the two being !=
187
165
  return iter != all_loggers.end();
188
166
}
189
167
 
190
 
/* Resets global stats for logging plugin */
191
 
bool plugin::Logging::resetStats(Session *session)
192
 
{
193
 
  std::vector<plugin::Logging *>::iterator iter=
194
 
    std::find_if(all_loggers.begin(), all_loggers.end(),
195
 
                 ResetIterate(session));
196
 
 
197
 
  return iter != all_loggers.end();
198
 
}
199
 
 
200
168
} /* namespace drizzled */