← Back to branch summary

~brianaker/libmemcached/merge-1.0-april-2013

« back to all changes in this revision

Viewing changes to libmemcached/error.cc

  • Committer: Continuous Integration
  • Date: 2013-01-14 21:10:11 UTC
  • mfrom: (1094.1.2 libmemcached-1.2)
  • Revision ID: ci@tangent.org-20130114211011-qql124fta45s730w
Merge lp:~tangent-org/libmemcached/1.2-build/ Build: jenkins-Libmemcached-199

Show diffs side-by-side

added added

removed removed

Lines of Context:
libmemcached/error.cc
50
50
  char message[MAX_ERROR_LENGTH];
51
51
};
52
52
 
53
 
static void _set(org::libmemcached::Instance& server, memcached_st& memc)
 
53
static void _set(org::libmemcached::Instance& server, Memcached& memc)
54
54
{
55
55
  if (server.error_messages and server.error_messages->query_id != server.root->query_id)
56
56
  {
153
153
 
154
154
  if (str and str->size and local_errno)
155
155
  {
156
 
    error->size= (int)snprintf(error->message, MAX_ERROR_LENGTH, "(%lu) %s(%s), %.*s -> %s", 
157
 
                               long(error->root),
 
156
    error->size= (int)snprintf(error->message, MAX_ERROR_LENGTH, "(%p) %s(%s), %.*s -> %s", 
 
157
                               error->root,
158
158
                               memcached_strerror(&memc, rc), 
159
159
                               errmsg_ptr,
160
160
                               memcached_string_printf(*str), at);
161
161
  }
162
162
  else if (local_errno)
163
163
  {
164
 
    error->size= (int)snprintf(error->message, MAX_ERROR_LENGTH, "(%lu) %s(%s) -> %s", 
165
 
                               long(error->root),
 
164
    error->size= (int)snprintf(error->message, MAX_ERROR_LENGTH, "(%p) %s(%s) -> %s", 
 
165
                               error->root,
166
166
                               memcached_strerror(&memc, rc), 
167
167
                               errmsg_ptr,
168
168
                               at);
169
169
  }
170
170
  else if (rc == MEMCACHED_PARSE_ERROR and str and str->size)
171
171
  {
172
 
    error->size= (int)snprintf(error->message, MAX_ERROR_LENGTH, "(%lu) %.*s -> %s", 
173
 
                               long(error->root),
 
172
    error->size= (int)snprintf(error->message, MAX_ERROR_LENGTH, "(%p) %.*s -> %s", 
 
173
                               error->root,
174
174
                               int(str->size), str->c_str, at);
175
175
  }
176
176
  else if (str and str->size)
177
177
  {
178
 
    error->size= (int)snprintf(error->message, MAX_ERROR_LENGTH, "(%lu) %s, %.*s -> %s", 
179
 
                               long(error->root),
 
178
    error->size= (int)snprintf(error->message, MAX_ERROR_LENGTH, "(%p) %s, %.*s -> %s", 
 
179
                               error->root,
180
180
                               memcached_strerror(&memc, rc), 
181
181
                               int(str->size), str->c_str, at);
182
182
  }
183
183
  else
184
184
  {
185
 
    error->size= (int)snprintf(error->message, MAX_ERROR_LENGTH, "(%lu) %s -> %s", 
186
 
                               long(error->root),
 
185
    error->size= (int)snprintf(error->message, MAX_ERROR_LENGTH, "(%p) %s -> %s", 
 
186
                               error->root,
187
187
                               memcached_strerror(&memc, rc), at);
188
188
  }
189
189
 
467
467
  _error_print(error->next);
468
468
}
469
469
 
470
 
void memcached_error_print(const memcached_st *self)
 
470
void memcached_error_print(const memcached_st *shell)
471
471
{
 
472
  const Memcached* self= memcached2Memcached(shell);
472
473
  if (self == NULL)
473
474
  {
474
475
    return;
517
518
  return memcached_last_error_message(memc);
518
519
}
519
520
 
520
 
const char *memcached_last_error_message(const memcached_st *memc)
 
521
const char *memcached_last_error_message(const memcached_st *shell)
521
522
{
 
523
  const Memcached* memc= memcached2Memcached(shell);
522
524
  if (memc)
523
525
  {
524
526
    if (memc->error_messages)
554
556
  return memcached_has_current_error(*(server.root));
555
557
}
556
558
 
557
 
memcached_return_t memcached_last_error(const memcached_st *memc)
 
559
memcached_return_t memcached_last_error(const memcached_st *shell)
558
560
{
 
561
  const Memcached* memc= memcached2Memcached(shell);
559
562
  if (memc)
560
563
  {
561
564
    if (memc->error_messages)
569
572
  return MEMCACHED_INVALID_ARGUMENTS;
570
573
}
571
574
 
572
 
int memcached_last_error_errno(const memcached_st *memc)
 
575
int memcached_last_error_errno(const memcached_st *shell)
573
576
{
 
577
  const Memcached* memc= memcached2Memcached(shell);
574
578
  if (memc == NULL)
575
579
  {
576
580
    return 0;