← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to drizzled/slot/error_message.cc

Merged in plugin-slot-reorg patches.

Show diffs side-by-side

added added

removed removed

Lines of Context:
drizzled/slot/error_message.cc
17
17
 *  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
18
18
 */
19
19
 
20
 
#include <drizzled/server_includes.h>
21
 
#include <drizzled/errmsg.h>
22
 
#include <drizzled/gettext.h>
 
20
#include "drizzled/server_includes.h"
 
21
#include "drizzled/slot/error_message.h"
 
22
#include "drizzled/plugin/error_message.h"
23
23
#include "drizzled/plugin/registry.h"
24
24
 
 
25
#include "drizzled/gettext.h"
 
26
 
25
27
#include <vector>
26
28
 
 
29
using namespace drizzled;
27
30
using namespace std;
28
31
 
29
 
static vector<Error_message_handler *> all_errmsg_handler;
30
 
 
31
 
static bool errmsg_has= false;
32
 
 
33
 
void add_errmsg_handler(Error_message_handler *handler)
 
32
void slot::ErrorMessage::add(plugin::ErrorMessage *handler)
34
33
{
35
34
  all_errmsg_handler.push_back(handler);
36
35
  errmsg_has= true;
37
36
}
38
37
 
39
 
void remove_errmsg_handler(Error_message_handler *handler)
 
38
void slot::ErrorMessage::remove(plugin::ErrorMessage *handler)
40
39
{
41
40
  all_errmsg_handler.erase(find(all_errmsg_handler.begin(),
42
41
                                all_errmsg_handler.end(), handler));
43
42
}
44
43
 
45
44
 
46
 
class ErrorMessagePrint : public unary_function<Error_message_handler *, bool>
 
45
namespace drizzled
 
46
{
 
47
namespace slot
 
48
{
 
49
namespace errmsg_priv
 
50
{
 
51
 
 
52
class Print : public unary_function<plugin::ErrorMessage *, bool>
47
53
{
48
54
  Session *session;
49
55
  int priority;
50
56
  const char *format;
51
57
  va_list ap;
52
58
public:
53
 
  ErrorMessagePrint(Session *session_arg, int priority_arg,
54
 
                    const char *format_arg, va_list ap_arg) :
55
 
    unary_function<Error_message_handler *, bool>(), session(session_arg),
56
 
    priority(priority_arg), format(format_arg)
 
59
  Print(Session *session_arg, int priority_arg,
 
60
        const char *format_arg, va_list ap_arg)
 
61
    : unary_function<plugin::ErrorMessage *, bool>(), session(session_arg),
 
62
      priority(priority_arg), format(format_arg)
57
63
    {
58
64
      va_copy(ap, ap_arg);
59
65
    }
60
66
 
61
 
  ~ErrorMessagePrint()  { va_end(ap); }
 
67
  ~Print()  { va_end(ap); }
62
68
 
63
69
  inline result_type operator()(argument_type handler)
64
70
  {
76
82
    }
77
83
    return false;
78
84
  }
79
 
};
80
 
 
81
 
bool errmsg_vprintf (Session *session, int priority,
82
 
                     char const *format, va_list ap)
 
85
}; 
 
86
 
 
87
} /* namespace errmsg_priv */
 
88
} /* namespace slot */
 
89
} /* namespace drizzled */
 
90
 
 
91
bool slot::ErrorMessage::vprintf(Session *session, int priority,
 
92
                                 char const *format, va_list ap)
83
93
{
84
94
 
85
95
  /* check to see if any errmsg plugin has been loaded
95
105
  }
96
106
 
97
107
  /* Use find_if instead of foreach so that we can collect return codes */
98
 
  vector<Error_message_handler *>::iterator iter=
 
108
  vector<plugin::ErrorMessage *>::iterator iter=
99
109
    find_if(all_errmsg_handler.begin(), all_errmsg_handler.end(),
100
 
            ErrorMessagePrint(session, priority, format, ap)); 
 
110
            slot::errmsg_priv::Print(session, priority, format, ap)); 
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 !=