← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to drizzled/plugin/error_message.cc

  • Committer: Monty Taylor
  • Date: 2011-02-13 17:26:39 UTC
  • mfrom: (2157.2.2 give-in-to-pkg-config)
  • mto: This revision was merged to the branch mainline in revision 2166.
  • Revision ID: mordred@inaugust.com-20110213172639-nhy7i72sfhoq13ms
Merged in pkg-config fixes.

Show diffs side-by-side

added added

removed removed

Lines of Context:
drizzled/plugin/error_message.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
 
4
 *  Copyright (C) 2008 Sun Microsystems, Inc.
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
26
26
#include <algorithm>
27
27
#include <vector>
28
28
 
29
 
using namespace std;
30
 
 
31
29
namespace drizzled
32
30
{
33
31
 
34
 
vector<plugin::ErrorMessage *> all_errmsg_handler;
35
 
bool errmsg_has= false;
36
 
 
 
32
std::vector<plugin::ErrorMessage *> all_errmsg_handler;
37
33
 
38
34
bool plugin::ErrorMessage::addPlugin(plugin::ErrorMessage *handler)
39
35
{
40
36
  all_errmsg_handler.push_back(handler);
41
 
  errmsg_has= true;
42
37
  return false;
43
38
}
44
39
 
45
 
void plugin::ErrorMessage::removePlugin(plugin::ErrorMessage *handler)
 
40
void plugin::ErrorMessage::removePlugin(plugin::ErrorMessage *)
46
41
{
47
 
  all_errmsg_handler.erase(find(all_errmsg_handler.begin(),
48
 
                                all_errmsg_handler.end(), handler));
 
42
  all_errmsg_handler.clear();
49
43
}
50
44
 
51
45
 
52
 
class Print : public unary_function<plugin::ErrorMessage *, bool>
 
46
class Print : public std::unary_function<plugin::ErrorMessage *, bool>
53
47
{
54
 
  Session *session;
55
 
  int priority;
 
48
  error::level_t priority;
56
49
  const char *format;
57
50
  va_list ap;
 
51
 
58
52
public:
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)
63
 
    {
64
 
      va_copy(ap, ap_arg);
65
 
    }
 
53
  Print(error::level_t priority_arg,
 
54
        const char *format_arg, va_list ap_arg) : 
 
55
    std::unary_function<plugin::ErrorMessage *, bool>(),
 
56
    priority(priority_arg), format(format_arg)
 
57
  {
 
58
    va_copy(ap, ap_arg);
 
59
  }
66
60
 
67
61
  ~Print()  { va_end(ap); }
68
62
 
70
64
  {
71
65
    va_list handler_ap;
72
66
    va_copy(handler_ap, ap);
73
 
    if (handler->errmsg(session, priority, format, handler_ap))
 
67
    if (handler->errmsg(priority, format, handler_ap))
74
68
    {
75
69
      /* we're doing the errmsg plugin api,
76
70
         so we can't trust the errmsg api to emit our error messages
89
83
}; 
90
84
 
91
85
 
92
 
bool plugin::ErrorMessage::vprintf(Session *session, int priority,
93
 
                                   char const *format, va_list ap)
 
86
bool plugin::ErrorMessage::vprintf(error::level_t priority, char const *format, va_list ap)
94
87
{
95
88
 
96
 
  /* check to see if any errmsg plugin has been loaded
97
 
     if not, just fall back to emitting the message to stderr */
98
 
  if (!errmsg_has)
 
89
  /* 
 
90
    Check to see if any errmsg plugin has been loaded
 
91
    if not, just fall back to emitting the message to stderr.
 
92
  */
 
93
  if (not all_errmsg_handler.size())
99
94
  {
100
95
    /* if it turns out that the vfprintf doesnt do one single write
101
96
       (single writes are atomic), then this needs to be rewritten to
102
97
       vsprintf into a char buffer, and then write() that char buffer
103
98
       to stderr */
104
99
    vfprintf(stderr, format, ap);
 
100
    fputc('\n', stderr);
105
101
    return false;
106
102
  }
107
103
 
108
104
  /* Use find_if instead of foreach so that we can collect return codes */
109
 
  vector<plugin::ErrorMessage *>::iterator iter=
110
 
    find_if(all_errmsg_handler.begin(), all_errmsg_handler.end(),
111
 
            Print(session, priority, format, ap)); 
 
105
  std::vector<plugin::ErrorMessage *>::iterator iter=
 
106
    std::find_if(all_errmsg_handler.begin(), all_errmsg_handler.end(),
 
107
                 Print(priority, format, ap)); 
 
108
 
112
109
  /* If iter is == end() here, that means that all of the plugins returned
113
110
   * false, which in this case means they all succeeded. Since we want to 
114
111
   * return false on success, we return the value of the two being !=