← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to drizzled/slot/logging.cc

Merged in plugin-slot-reorg patches.

Show diffs side-by-side

added added

removed removed

Lines of Context:
drizzled/slot/logging.cc
18
18
 */
19
19
 
20
20
#include <drizzled/server_includes.h>
21
 
#include <drizzled/logging.h>
 
21
#include <drizzled/slot/logging.h>
22
22
#include <drizzled/gettext.h>
23
23
#include "drizzled/plugin/registry.h"
24
24
 
25
25
#include <vector>
26
26
 
 
27
using namespace drizzled;
27
28
using namespace std;
28
29
 
29
 
static vector<Logging_handler *> all_loggers;
30
 
 
31
 
void add_logger(Logging_handler *handler)
 
30
void slot::Logging::add(plugin::Logging *handler)
32
31
{
33
32
  if (handler != NULL)
34
33
    all_loggers.push_back(handler);
35
34
}
36
35
 
37
 
void remove_logger(Logging_handler *handler)
 
36
void slot::Logging::remove(plugin::Logging *handler)
38
37
{
39
38
  if (handler != NULL)
40
39
    all_loggers.erase(find(all_loggers.begin(), all_loggers.end(), handler));
41
40
}
42
41
 
43
42
 
44
 
class LoggingPreIterate : public unary_function<Logging_handler *, bool>
 
43
namespace drizzled
 
44
{
 
45
namespace slot
 
46
{
 
47
namespace logging_priv
 
48
{
 
49
 
 
50
class PreIterate : public unary_function<plugin::Logging *, bool>
45
51
{
46
52
  Session *session;
47
53
public:
48
 
  LoggingPreIterate(Session *session_arg) :
49
 
    unary_function<Logging_handler *, bool>(),
 
54
  PreIterate(Session *session_arg) :
 
55
    unary_function<plugin::Logging *, bool>(),
50
56
    session(session_arg) {}
51
57
 
52
58
  inline result_type operator()(argument_type handler)
65
71
};
66
72
 
67
73
 
68
 
class LoggingPostIterate : public unary_function<Logging_handler *, bool>
 
74
class PostIterate : public unary_function<plugin::Logging *, bool>
69
75
{
70
76
  Session *session;
71
77
public:
72
 
  LoggingPostIterate(Session *session_arg) :
73
 
    unary_function<Logging_handler *, bool>(),
 
78
  PostIterate(Session *session_arg) :
 
79
    unary_function<plugin::Logging *, bool>(),
74
80
    session(session_arg) {}
75
81
 
76
82
  /* This gets called once for each loaded logging plugin */
89
95
  }
90
96
};
91
97
 
 
98
} /* namespace logging_priv */
 
99
} /* namespace slot */
 
100
} /* namespace drizzled */
 
101
 
92
102
 
93
103
/* This is the logging_pre_do entry point.
94
104
   This gets called by the rest of the Drizzle server code */
95
 
bool logging_pre_do (Session *session)
 
105
bool slot::Logging::pre_do(Session *session)
96
106
{
97
107
  /* Use find_if instead of foreach so that we can collect return codes */
98
 
  vector<Logging_handler *>::iterator iter=
 
108
  vector<plugin::Logging *>::iterator iter=
99
109
    find_if(all_loggers.begin(), all_loggers.end(),
100
 
            LoggingPreIterate(session)); 
 
110
            slot::logging_priv::PreIterate(session)); 
101
111
  /* If iter is == end() here, that means that all of the plugins returned
102
112
   * false, which in this case means they all succeeded. Since we want to 
103
113
   * return false on success, we return the value of the two being != 
107
117
 
108
118
/* This is the logging_post_do entry point.
109
119
   This gets called by the rest of the Drizzle server code */
110
 
bool logging_post_do (Session *session)
 
120
bool slot::Logging::post_do(Session *session)
111
121
{
112
122
  /* Use find_if instead of foreach so that we can collect return codes */
113
 
  vector<Logging_handler *>::iterator iter=
 
123
  vector<plugin::Logging *>::iterator iter=
114
124
    find_if(all_loggers.begin(), all_loggers.end(),
115
 
            LoggingPostIterate(session)); 
 
125
            slot::logging_priv::PostIterate(session)); 
116
126
  /* If iter is == end() here, that means that all of the plugins returned
117
127
   * false, which in this case means they all succeeded. Since we want to 
118
128
   * return false on success, we return the value of the two being !=