source/lib/ldb/ldb_wrap.c

   1 /* ----------------------------------------------------------------------------
   2  * This file was automatically generated by SWIG (http://www.swig.org).
   3  * Version 1.3.35
   4  *
   5  * This file is not intended to be easily readable and contains a number of
   6  * coding conventions designed to improve portability and efficiency. Do not make
   7  * changes to this file unless you know what you are doing--modify the SWIG
   8  * interface file instead.
   9  * ----------------------------------------------------------------------------- */
  10
  11 #define SWIGPYTHON
  12 #define SWIG_PYTHON_NO_BUILD_NONE
  13 /* -----------------------------------------------------------------------------
  14  *  This section contains generic SWIG labels for method/variable
  15  *  declarations/attributes, and other compiler dependent labels.
  16  * ----------------------------------------------------------------------------- */
  17
  18 /* template workaround for compilers that cannot correctly implement the C++ standard */
  19 #ifndef SWIGTEMPLATEDISAMBIGUATOR
  20 # if defined(__SUNPRO_CC) && (__SUNPRO_CC <= 0x560)
  21 #  define SWIGTEMPLATEDISAMBIGUATOR template
  22 # elif defined(__HP_aCC)
  23 /* Needed even with `aCC -AA' when `aCC -V' reports HP ANSI C++ B3910B A.03.55 */
  24 /* If we find a maximum version that requires this, the test would be __HP_aCC <= 35500 for A.03.55 */
  25 #  define SWIGTEMPLATEDISAMBIGUATOR template
  26 # else
  27 #  define SWIGTEMPLATEDISAMBIGUATOR
  28 # endif
  29 #endif
  30
  31 /* inline attribute */
  32 #ifndef SWIGINLINE
  33 # if defined(__cplusplus) || (defined(__GNUC__) && !defined(__STRICT_ANSI__))
  34 #   define SWIGINLINE inline
  35 # else
  36 #   define SWIGINLINE
  37 # endif
  38 #endif
  39
  40 /* attribute recognised by some compilers to avoid 'unused' warnings */
  41 #ifndef SWIGUNUSED
  42 # if defined(__GNUC__)
  43 #   if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4))
  44 #     define SWIGUNUSED __attribute__ ((__unused__))
  45 #   else
  46 #     define SWIGUNUSED
  47 #   endif
  48 # elif defined(__ICC)
  49 #   define SWIGUNUSED __attribute__ ((__unused__))
  50 # else
  51 #   define SWIGUNUSED
  52 # endif
  53 #endif
  54
  55 #ifndef SWIGUNUSEDPARM
  56 # ifdef __cplusplus
  57 #   define SWIGUNUSEDPARM(p)
  58 # else
  59 #   define SWIGUNUSEDPARM(p) p SWIGUNUSED
  60 # endif
  61 #endif
  62
  63 /* internal SWIG method */
  64 #ifndef SWIGINTERN
  65 # define SWIGINTERN static SWIGUNUSED
  66 #endif
  67
  68 /* internal inline SWIG method */
  69 #ifndef SWIGINTERNINLINE
  70 # define SWIGINTERNINLINE SWIGINTERN SWIGINLINE
  71 #endif
  72
  73 /* exporting methods */
  74 #if (__GNUC__ >= 4) || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)
  75 #  ifndef GCC_HASCLASSVISIBILITY
  76 #    define GCC_HASCLASSVISIBILITY
  77 #  endif
  78 #endif
  79
  80 #ifndef SWIGEXPORT
  81 # if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
  82 #   if defined(STATIC_LINKED)
  83 #     define SWIGEXPORT
  84 #   else
  85 #     define SWIGEXPORT __declspec(dllexport)
  86 #   endif
  87 # else
  88 #   if defined(__GNUC__) && defined(GCC_HASCLASSVISIBILITY)
  89 #     define SWIGEXPORT __attribute__ ((visibility("default")))
  90 #   else
  91 #     define SWIGEXPORT
  92 #   endif
  93 # endif
  94 #endif
  95
  96 /* calling conventions for Windows */
  97 #ifndef SWIGSTDCALL
  98 # if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
  99 #   define SWIGSTDCALL __stdcall
 100 # else
 101 #   define SWIGSTDCALL
 102 # endif
 103 #endif
 104
 105 /* Deal with Microsoft's attempt at deprecating C standard runtime functions */
 106 #if !defined(SWIG_NO_CRT_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_CRT_SECURE_NO_DEPRECATE)
 107 # define _CRT_SECURE_NO_DEPRECATE
 108 #endif
 109
 110 /* Deal with Microsoft's attempt at deprecating methods in the standard C++ library */
 111 #if !defined(SWIG_NO_SCL_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_SCL_SECURE_NO_DEPRECATE)
 112 # define _SCL_SECURE_NO_DEPRECATE
 113 #endif
 114
 115
 116
 117 /* Python.h has to appear first */
 118 #include <Python.h>
 119
 120 /* -----------------------------------------------------------------------------
 121  * swigrun.swg
 122  *
 123  * This file contains generic CAPI SWIG runtime support for pointer
 124  * type checking.
 125  * ----------------------------------------------------------------------------- */
 126
 127 /* This should only be incremented when either the layout of swig_type_info changes,
 128    or for whatever reason, the runtime changes incompatibly */
 129 #define SWIG_RUNTIME_VERSION "4"
 130
 131 /* define SWIG_TYPE_TABLE_NAME as "SWIG_TYPE_TABLE" */
 132 #ifdef SWIG_TYPE_TABLE
 133 # define SWIG_QUOTE_STRING(x) #x
 134 # define SWIG_EXPAND_AND_QUOTE_STRING(x) SWIG_QUOTE_STRING(x)
 135 # define SWIG_TYPE_TABLE_NAME SWIG_EXPAND_AND_QUOTE_STRING(SWIG_TYPE_TABLE)
 136 #else
 137 # define SWIG_TYPE_TABLE_NAME
 138 #endif
 139
 140 /*
 141   You can use the SWIGRUNTIME and SWIGRUNTIMEINLINE macros for
 142   creating a static or dynamic library from the swig runtime code.
 143   In 99.9% of the cases, swig just needs to declare them as 'static'.
 144
 145   But only do this if is strictly necessary, ie, if you have problems
 146   with your compiler or so.
 147 */
 148
 149 #ifndef SWIGRUNTIME
 150 # define SWIGRUNTIME SWIGINTERN
 151 #endif
 152
 153 #ifndef SWIGRUNTIMEINLINE
 154 # define SWIGRUNTIMEINLINE SWIGRUNTIME SWIGINLINE
 155 #endif
 156
 157 /*  Generic buffer size */
 158 #ifndef SWIG_BUFFER_SIZE
 159 # define SWIG_BUFFER_SIZE 1024
 160 #endif
 161
 162 /* Flags for pointer conversions */
 163 #define SWIG_POINTER_DISOWN        0x1
 164 #define SWIG_CAST_NEW_MEMORY       0x2
 165
 166 /* Flags for new pointer objects */
 167 #define SWIG_POINTER_OWN           0x1
 168
 169
 170 /*
 171    Flags/methods for returning states.
 172
 173    The swig conversion methods, as ConvertPtr, return and integer
 174    that tells if the conversion was successful or not. And if not,
 175    an error code can be returned (see swigerrors.swg for the codes).
 176
 177    Use the following macros/flags to set or process the returning
 178    states.
 179
 180    In old swig versions, you usually write code as:
 181
 182      if (SWIG_ConvertPtr(obj,vptr,ty.flags) != -1) {
 183        // success code
 184      } else {
 185        //fail code
 186      }
 187
 188    Now you can be more explicit as:
 189
 190     int res = SWIG_ConvertPtr(obj,vptr,ty.flags);
 191     if (SWIG_IsOK(res)) {
 192       // success code
 193     } else {
 194       // fail code
 195     }
 196
 197    that seems to be the same, but now you can also do
 198
 199     Type *ptr;
 200     int res = SWIG_ConvertPtr(obj,(void **)(&ptr),ty.flags);
 201     if (SWIG_IsOK(res)) {
 202       // success code
 203       if (SWIG_IsNewObj(res) {
 204         ...
 205         delete *ptr;
 206       } else {
 207         ...
 208       }
 209     } else {
 210       // fail code
 211     }
 212
 213    I.e., now SWIG_ConvertPtr can return new objects and you can
 214    identify the case and take care of the deallocation. Of course that
 215    requires also to SWIG_ConvertPtr to return new result values, as
 216
 217       int SWIG_ConvertPtr(obj, ptr,...) {
 218         if (<obj is ok>) {
 219           if (<need new object>) {
 220             *ptr = <ptr to new allocated object>;
 221             return SWIG_NEWOBJ;
 222           } else {
 223             *ptr = <ptr to old object>;
 224             return SWIG_OLDOBJ;
 225           }
 226         } else {
 227           return SWIG_BADOBJ;
 228         }
 229       }
 230
 231    Of course, returning the plain '0(success)/-1(fail)' still works, but you can be
 232    more explicit by returning SWIG_BADOBJ, SWIG_ERROR or any of the
 233    swig errors code.
 234
 235    Finally, if the SWIG_CASTRANK_MODE is enabled, the result code
 236    allows to return the 'cast rank', for example, if you have this
 237
 238        int food(double)
 239        int fooi(int);
 240
 241    and you call
 242
 243       food(1)   // cast rank '1'  (1 -> 1.0)
 244       fooi(1)   // cast rank '0'
 245
 246    just use the SWIG_AddCast()/SWIG_CheckState()
 247
 248
 249  */
 250 #define SWIG_OK                    (0)
 251 #define SWIG_ERROR                 (-1)
 252 #define SWIG_IsOK(r)               (r >= 0)
 253 #define SWIG_ArgError(r)           ((r != SWIG_ERROR) ? r : SWIG_TypeError)
 254
 255 /* The CastRankLimit says how many bits are used for the cast rank */
 256 #define SWIG_CASTRANKLIMIT         (1 << 8)
 257 /* The NewMask denotes the object was created (using new/malloc) */
 258 #define SWIG_NEWOBJMASK            (SWIG_CASTRANKLIMIT  << 1)
 259 /* The TmpMask is for in/out typemaps that use temporal objects */
 260 #define SWIG_TMPOBJMASK            (SWIG_NEWOBJMASK << 1)
 261 /* Simple returning values */
 262 #define SWIG_BADOBJ                (SWIG_ERROR)
 263 #define SWIG_OLDOBJ                (SWIG_OK)
 264 #define SWIG_NEWOBJ                (SWIG_OK | SWIG_NEWOBJMASK)
 265 #define SWIG_TMPOBJ                (SWIG_OK | SWIG_TMPOBJMASK)
 266 /* Check, add and del mask methods */
 267 #define SWIG_AddNewMask(r)         (SWIG_IsOK(r) ? (r | SWIG_NEWOBJMASK) : r)
 268 #define SWIG_DelNewMask(r)         (SWIG_IsOK(r) ? (r & ~SWIG_NEWOBJMASK) : r)
 269 #define SWIG_IsNewObj(r)           (SWIG_IsOK(r) && (r & SWIG_NEWOBJMASK))
 270 #define SWIG_AddTmpMask(r)         (SWIG_IsOK(r) ? (r | SWIG_TMPOBJMASK) : r)
 271 #define SWIG_DelTmpMask(r)         (SWIG_IsOK(r) ? (r & ~SWIG_TMPOBJMASK) : r)
 272 #define SWIG_IsTmpObj(r)           (SWIG_IsOK(r) && (r & SWIG_TMPOBJMASK))
 273
 274
 275 /* Cast-Rank Mode */
 276 #if defined(SWIG_CASTRANK_MODE)
 277 #  ifndef SWIG_TypeRank
 278 #    define SWIG_TypeRank             unsigned long
 279 #  endif
 280 #  ifndef SWIG_MAXCASTRANK            /* Default cast allowed */
 281 #    define SWIG_MAXCASTRANK          (2)
 282 #  endif
 283 #  define SWIG_CASTRANKMASK          ((SWIG_CASTRANKLIMIT) -1)
 284 #  define SWIG_CastRank(r)           (r & SWIG_CASTRANKMASK)
 285 SWIGINTERNINLINE int SWIG_AddCast(int r) {
 286   return SWIG_IsOK(r) ? ((SWIG_CastRank(r) < SWIG_MAXCASTRANK) ? (r + 1) : SWIG_ERROR) : r;
 287 }
 288 SWIGINTERNINLINE int SWIG_CheckState(int r) {
 289   return SWIG_IsOK(r) ? SWIG_CastRank(r) + 1 : 0;
 290 }
 291 #else /* no cast-rank mode */
 292 #  define SWIG_AddCast
 293 #  define SWIG_CheckState(r) (SWIG_IsOK(r) ? 1 : 0)
 294 #endif
 295
 296
 297
 298
 299 #include <string.h>
 300
 301 #ifdef __cplusplus
 302 extern "C" {
 303 #endif
 304
 305 typedef void *(*swig_converter_func)(void *, int *);
 306 typedef struct swig_type_info *(*swig_dycast_func)(void **);
 307
 308 /* Structure to store information on one type */
 309 typedef struct swig_type_info {
 310   const char             *name;                 /* mangled name of this type */
 311   const char             *str;                  /* human readable name of this type */
 312   swig_dycast_func        dcast;                /* dynamic cast function down a hierarchy */
 313   struct swig_cast_info  *cast;                 /* linked list of types that can cast into this type */
 314   void                   *clientdata;           /* language specific type data */
 315   int                    owndata;               /* flag if the structure owns the clientdata */
 316 } swig_type_info;
 317
 318 /* Structure to store a type and conversion function used for casting */
 319 typedef struct swig_cast_info {
 320   swig_type_info         *type;                 /* pointer to type that is equivalent to this type */
 321   swig_converter_func     converter;            /* function to cast the void pointers */
 322   struct swig_cast_info  *next;                 /* pointer to next cast in linked list */
 323   struct swig_cast_info  *prev;                 /* pointer to the previous cast */
 324 } swig_cast_info;
 325
 326 /* Structure used to store module information
 327  * Each module generates one structure like this, and the runtime collects
 328  * all of these structures and stores them in a circularly linked list.*/
 329 typedef struct swig_module_info {
 330   swig_type_info         **types;               /* Array of pointers to swig_type_info structures that are in this module */
 331   size_t                 size;                  /* Number of types in this module */
 332   struct swig_module_info *next;                /* Pointer to next element in circularly linked list */
 333   swig_type_info         **type_initial;        /* Array of initially generated type structures */
 334   swig_cast_info         **cast_initial;        /* Array of initially generated casting structures */
 335   void                    *clientdata;          /* Language specific module data */
 336 } swig_module_info;
 337
 338 /*
 339   Compare two type names skipping the space characters, therefore
 340   "char*" == "char *" and "Class<int>" == "Class<int >", etc.
 341
 342   Return 0 when the two name types are equivalent, as in
 343   strncmp, but skipping ' '.
 344 */
 345 SWIGRUNTIME int
 346 SWIG_TypeNameComp(const char *f1, const char *l1,
 347                   const char *f2, const char *l2) {
 348   for (;(f1 != l1) && (f2 != l2); ++f1, ++f2) {
 349     while ((*f1 == ' ') && (f1 != l1)) ++f1;
 350     while ((*f2 == ' ') && (f2 != l2)) ++f2;
 351     if (*f1 != *f2) return (*f1 > *f2) ? 1 : -1;
 352   }
 353   return (int)((l1 - f1) - (l2 - f2));
 354 }
 355
 356 /*
 357   Check type equivalence in a name list like <name1>|<name2>|...
 358   Return 0 if not equal, 1 if equal
 359 */
 360 SWIGRUNTIME int
 361 SWIG_TypeEquiv(const char *nb, const char *tb) {
 362   int equiv = 0;
 363   const char* te = tb + strlen(tb);
 364   const char* ne = nb;
 365   while (!equiv && *ne) {
 366     for (nb = ne; *ne; ++ne) {
 367       if (*ne == '|') break;
 368     }
 369     equiv = (SWIG_TypeNameComp(nb, ne, tb, te) == 0) ? 1 : 0;
 370     if (*ne) ++ne;
 371   }
 372   return equiv;
 373 }
 374
 375 /*
 376   Check type equivalence in a name list like <name1>|<name2>|...
 377   Return 0 if equal, -1 if nb < tb, 1 if nb > tb
 378 */
 379 SWIGRUNTIME int
 380 SWIG_TypeCompare(const char *nb, const char *tb) {
 381   int equiv = 0;
 382   const char* te = tb + strlen(tb);
 383   const char* ne = nb;
 384   while (!equiv && *ne) {
 385     for (nb = ne; *ne; ++ne) {
 386       if (*ne == '|') break;
 387     }
 388     equiv = (SWIG_TypeNameComp(nb, ne, tb, te) == 0) ? 1 : 0;
 389     if (*ne) ++ne;
 390   }
 391   return equiv;
 392 }
 393
 394
 395 /* think of this as a c++ template<> or a scheme macro */
 396 #define SWIG_TypeCheck_Template(comparison, ty)         \
 397   if (ty) {                                             \
 398     swig_cast_info *iter = ty->cast;                    \
 399     while (iter) {                                      \
 400       if (comparison) {                                 \
 401         if (iter == ty->cast) return iter;              \
 402         /* Move iter to the top of the linked list */   \
 403         iter->prev->next = iter->next;                  \
 404         if (iter->next)                                 \
 405           iter->next->prev = iter->prev;                \
 406         iter->next = ty->cast;                          \
 407         iter->prev = 0;                                 \
 408         if (ty->cast) ty->cast->prev = iter;            \
 409         ty->cast = iter;                                \
 410         return iter;                                    \
 411       }                                                 \
 412       iter = iter->next;                                \
 413     }                                                   \
 414   }                                                     \
 415   return 0
 416
 417 /*
 418   Check the typename
 419 */
 420 SWIGRUNTIME swig_cast_info *
 421 SWIG_TypeCheck(const char *c, swig_type_info *ty) {
 422   SWIG_TypeCheck_Template(strcmp(iter->type->name, c) == 0, ty);
 423 }
 424
 425 /* Same as previous function, except strcmp is replaced with a pointer comparison */
 426 SWIGRUNTIME swig_cast_info *
 427 SWIG_TypeCheckStruct(swig_type_info *from, swig_type_info *into) {
 428   SWIG_TypeCheck_Template(iter->type == from, into);
 429 }
 430
 431 /*
 432   Cast a pointer up an inheritance hierarchy
 433 */
 434 SWIGRUNTIMEINLINE void *
 435 SWIG_TypeCast(swig_cast_info *ty, void *ptr, int *newmemory) {
 436   return ((!ty) || (!ty->converter)) ? ptr : (*ty->converter)(ptr, newmemory);
 437 }
 438
 439 /*
 440    Dynamic pointer casting. Down an inheritance hierarchy
 441 */
 442 SWIGRUNTIME swig_type_info *
 443 SWIG_TypeDynamicCast(swig_type_info *ty, void **ptr) {
 444   swig_type_info *lastty = ty;
 445   if (!ty || !ty->dcast) return ty;
 446   while (ty && (ty->dcast)) {
 447     ty = (*ty->dcast)(ptr);
 448     if (ty) lastty = ty;
 449   }
 450   return lastty;
 451 }
 452
 453 /*
 454   Return the name associated with this type
 455 */
 456 SWIGRUNTIMEINLINE const char *
 457 SWIG_TypeName(const swig_type_info *ty) {
 458   return ty->name;
 459 }
 460
 461 /*
 462   Return the pretty name associated with this type,
 463   that is an unmangled type name in a form presentable to the user.
 464 */
 465 SWIGRUNTIME const char *
 466 SWIG_TypePrettyName(const swig_type_info *type) {
 467   /* The "str" field contains the equivalent pretty names of the
 468      type, separated by vertical-bar characters.  We choose
 469      to print the last name, as it is often (?) the most
 470      specific. */
 471   if (!type) return NULL;
 472   if (type->str != NULL) {
 473     const char *last_name = type->str;
 474     const char *s;
 475     for (s = type->str; *s; s++)
 476       if (*s == '|') last_name = s+1;
 477     return last_name;
 478   }
 479   else
 480     return type->name;
 481 }
 482
 483 /*
 484    Set the clientdata field for a type
 485 */
 486 SWIGRUNTIME void
 487 SWIG_TypeClientData(swig_type_info *ti, void *clientdata) {
 488   swig_cast_info *cast = ti->cast;
 489   /* if (ti->clientdata == clientdata) return; */
 490   ti->clientdata = clientdata;
 491
 492   while (cast) {
 493     if (!cast->converter) {
 494       swig_type_info *tc = cast->type;
 495       if (!tc->clientdata) {
 496         SWIG_TypeClientData(tc, clientdata);
 497       }
 498     }
 499     cast = cast->next;
 500   }
 501 }
 502 SWIGRUNTIME void
 503 SWIG_TypeNewClientData(swig_type_info *ti, void *clientdata) {
 504   SWIG_TypeClientData(ti, clientdata);
 505   ti->owndata = 1;
 506 }
 507
 508 /*
 509   Search for a swig_type_info structure only by mangled name
 510   Search is a O(log #types)
 511
 512   We start searching at module start, and finish searching when start == end.
 513   Note: if start == end at the beginning of the function, we go all the way around
 514   the circular list.
 515 */
 516 SWIGRUNTIME swig_type_info *
 517 SWIG_MangledTypeQueryModule(swig_module_info *start,
 518                             swig_module_info *end,
 519                             const char *name) {
 520   swig_module_info *iter = start;
 521   do {
 522     if (iter->size) {
 523       register size_t l = 0;
 524       register size_t r = iter->size - 1;
 525       do {
 526         /* since l+r >= 0, we can (>> 1) instead (/ 2) */
 527         register size_t i = (l + r) >> 1;
 528         const char *iname = iter->types[i]->name;
 529         if (iname) {
 530           register int compare = strcmp(name, iname);
 531           if (compare == 0) {
 532             return iter->types[i];
 533           } else if (compare < 0) {
 534             if (i) {
 535               r = i - 1;
 536             } else {
 537               break;
 538             }
 539           } else if (compare > 0) {
 540             l = i + 1;
 541           }
 542         } else {
 543           break; /* should never happen */
 544         }
 545       } while (l <= r);
 546     }
 547     iter = iter->next;
 548   } while (iter != end);
 549   return 0;
 550 }
 551
 552 /*
 553   Search for a swig_type_info structure for either a mangled name or a human readable name.
 554   It first searches the mangled names of the types, which is a O(log #types)
 555   If a type is not found it then searches the human readable names, which is O(#types).
 556
 557   We start searching at module start, and finish searching when start == end.
 558   Note: if start == end at the beginning of the function, we go all the way around
 559   the circular list.
 560 */
 561 SWIGRUNTIME swig_type_info *
 562 SWIG_TypeQueryModule(swig_module_info *start,
 563                      swig_module_info *end,
 564                      const char *name) {
 565   /* STEP 1: Search the name field using binary search */
 566   swig_type_info *ret = SWIG_MangledTypeQueryModule(start, end, name);
 567   if (ret) {
 568     return ret;
 569   } else {
 570     /* STEP 2: If the type hasn't been found, do a complete search
 571        of the str field (the human readable name) */
 572     swig_module_info *iter = start;
 573     do {
 574       register size_t i = 0;
 575       for (; i < iter->size; ++i) {
 576         if (iter->types[i]->str && (SWIG_TypeEquiv(iter->types[i]->str, name)))
 577           return iter->types[i];
 578       }
 579       iter = iter->next;
 580     } while (iter != end);
 581   }
 582
 583   /* neither found a match */
 584   return 0;
 585 }
 586
 587 /*
 588    Pack binary data into a string
 589 */
 590 SWIGRUNTIME char *
 591 SWIG_PackData(char *c, void *ptr, size_t sz) {
 592   static const char hex[17] = "0123456789abcdef";
 593   register const unsigned char *u = (unsigned char *) ptr;
 594   register const unsigned char *eu =  u + sz;
 595   for (; u != eu; ++u) {
 596     register unsigned char uu = *u;
 597     *(c++) = hex[(uu & 0xf0) >> 4];
 598     *(c++) = hex[uu & 0xf];
 599   }
 600   return c;
 601 }
 602
 603 /*
 604    Unpack binary data from a string
 605 */
 606 SWIGRUNTIME const char *
 607 SWIG_UnpackData(const char *c, void *ptr, size_t sz) {
 608   register unsigned char *u = (unsigned char *) ptr;
 609   register const unsigned char *eu = u + sz;
 610   for (; u != eu; ++u) {
 611     register char d = *(c++);
 612     register unsigned char uu;
 613     if ((d >= '0') && (d <= '9'))
 614       uu = ((d - '0') << 4);
 615     else if ((d >= 'a') && (d <= 'f'))
 616       uu = ((d - ('a'-10)) << 4);
 617     else
 618       return (char *) 0;
 619     d = *(c++);
 620     if ((d >= '0') && (d <= '9'))
 621       uu |= (d - '0');
 622     else if ((d >= 'a') && (d <= 'f'))
 623       uu |= (d - ('a'-10));
 624     else
 625       return (char *) 0;
 626     *u = uu;
 627   }
 628   return c;
 629 }
 630
 631 /*
 632    Pack 'void *' into a string buffer.
 633 */
 634 SWIGRUNTIME char *
 635 SWIG_PackVoidPtr(char *buff, void *ptr, const char *name, size_t bsz) {
 636   char *r = buff;
 637   if ((2*sizeof(void *) + 2) > bsz) return 0;
 638   *(r++) = '_';
 639   r = SWIG_PackData(r,&ptr,sizeof(void *));
 640   if (strlen(name) + 1 > (bsz - (r - buff))) return 0;
 641   strcpy(r,name);
 642   return buff;
 643 }
 644
 645 SWIGRUNTIME const char *
 646 SWIG_UnpackVoidPtr(const char *c, void **ptr, const char *name) {
 647   if (*c != '_') {
 648     if (strcmp(c,"NULL") == 0) {
 649       *ptr = (void *) 0;
 650       return name;
 651     } else {
 652       return 0;
 653     }
 654   }
 655   return SWIG_UnpackData(++c,ptr,sizeof(void *));
 656 }
 657
 658 SWIGRUNTIME char *
 659 SWIG_PackDataName(char *buff, void *ptr, size_t sz, const char *name, size_t bsz) {
 660   char *r = buff;
 661   size_t lname = (name ? strlen(name) : 0);
 662   if ((2*sz + 2 + lname) > bsz) return 0;
 663   *(r++) = '_';
 664   r = SWIG_PackData(r,ptr,sz);
 665   if (lname) {
 666     strncpy(r,name,lname+1);
 667   } else {
 668     *r = 0;
 669   }
 670   return buff;
 671 }
 672
 673 SWIGRUNTIME const char *
 674 SWIG_UnpackDataName(const char *c, void *ptr, size_t sz, const char *name) {
 675   if (*c != '_') {
 676     if (strcmp(c,"NULL") == 0) {
 677       memset(ptr,0,sz);
 678       return name;
 679     } else {
 680       return 0;
 681     }
 682   }
 683   return SWIG_UnpackData(++c,ptr,sz);
 684 }
 685
 686 #ifdef __cplusplus
 687 }
 688 #endif
 689
 690 /*  Errors in SWIG */
 691 #define  SWIG_UnknownError         -1
 692 #define  SWIG_IOError              -2
 693 #define  SWIG_RuntimeError         -3
 694 #define  SWIG_IndexError           -4
 695 #define  SWIG_TypeError            -5
 696 #define  SWIG_DivisionByZero       -6
 697 #define  SWIG_OverflowError        -7
 698 #define  SWIG_SyntaxError          -8
 699 #define  SWIG_ValueError           -9
 700 #define  SWIG_SystemError          -10
 701 #define  SWIG_AttributeError       -11
 702 #define  SWIG_MemoryError          -12
 703 #define  SWIG_NullReferenceError   -13
 704
 705
 706
 707
 708 /* Add PyOS_snprintf for old Pythons */
 709 #if PY_VERSION_HEX < 0x02020000
 710 # if defined(_MSC_VER) || defined(__BORLANDC__) || defined(_WATCOM)
 711 #  define PyOS_snprintf _snprintf
 712 # else
 713 #  define PyOS_snprintf snprintf
 714 # endif
 715 #endif
 716
 717 /* A crude PyString_FromFormat implementation for old Pythons */
 718 #if PY_VERSION_HEX < 0x02020000
 719
 720 #ifndef SWIG_PYBUFFER_SIZE
 721 # define SWIG_PYBUFFER_SIZE 1024
 722 #endif
 723
 724 static PyObject *
 725 PyString_FromFormat(const char *fmt, ...) {
 726   va_list ap;
 727   char buf[SWIG_PYBUFFER_SIZE * 2];
 728   int res;
 729   va_start(ap, fmt);
 730   res = vsnprintf(buf, sizeof(buf), fmt, ap);
 731   va_end(ap);
 732   return (res < 0 || res >= (int)sizeof(buf)) ? 0 : PyString_FromString(buf);
 733 }
 734 #endif
 735
 736 /* Add PyObject_Del for old Pythons */
 737 #if PY_VERSION_HEX < 0x01060000
 738 # define PyObject_Del(op) PyMem_DEL((op))
 739 #endif
 740 #ifndef PyObject_DEL
 741 # define PyObject_DEL PyObject_Del
 742 #endif
 743
 744 /* A crude PyExc_StopIteration exception for old Pythons */
 745 #if PY_VERSION_HEX < 0x02020000
 746 # ifndef PyExc_StopIteration
 747 #  define PyExc_StopIteration PyExc_RuntimeError
 748 # endif
 749 # ifndef PyObject_GenericGetAttr
 750 #  define PyObject_GenericGetAttr 0
 751 # endif
 752 #endif
 753 /* Py_NotImplemented is defined in 2.1 and up. */
 754 #if PY_VERSION_HEX < 0x02010000
 755 # ifndef Py_NotImplemented
 756 #  define Py_NotImplemented PyExc_RuntimeError
 757 # endif
 758 #endif
 759
 760
 761 /* A crude PyString_AsStringAndSize implementation for old Pythons */
 762 #if PY_VERSION_HEX < 0x02010000
 763 # ifndef PyString_AsStringAndSize
 764 #  define PyString_AsStringAndSize(obj, s, len) {*s = PyString_AsString(obj); *len = *s ? strlen(*s) : 0;}
 765 # endif
 766 #endif
 767
 768 /* PySequence_Size for old Pythons */
 769 #if PY_VERSION_HEX < 0x02000000
 770 # ifndef PySequence_Size
 771 #  define PySequence_Size PySequence_Length
 772 # endif
 773 #endif
 774
 775
 776 /* PyBool_FromLong for old Pythons */
 777 #if PY_VERSION_HEX < 0x02030000
 778 static
 779 PyObject *PyBool_FromLong(long ok)
 780 {
 781   PyObject *result = ok ? Py_True : Py_False;
 782   Py_INCREF(result);
 783   return result;
 784 }
 785 #endif
 786
 787 /* Py_ssize_t for old Pythons */
 788 /* This code is as recommended by: */
 789 /* http://www.python.org/dev/peps/pep-0353/#conversion-guidelines */
 790 #if PY_VERSION_HEX < 0x02050000 && !defined(PY_SSIZE_T_MIN)
 791 typedef int Py_ssize_t;
 792 # define PY_SSIZE_T_MAX INT_MAX
 793 # define PY_SSIZE_T_MIN INT_MIN
 794 #endif
 795
 796 /* -----------------------------------------------------------------------------
 797  * error manipulation
 798  * ----------------------------------------------------------------------------- */
 799
 800 SWIGRUNTIME PyObject*
 801 SWIG_Python_ErrorType(int code) {
 802   PyObject* type = 0;
 803   switch(code) {
 804   case SWIG_MemoryError:
 805     type = PyExc_MemoryError;
 806     break;
 807   case SWIG_IOError:
 808     type = PyExc_IOError;
 809     break;
 810   case SWIG_RuntimeError:
 811     type = PyExc_RuntimeError;
 812     break;
 813   case SWIG_IndexError:
 814     type = PyExc_IndexError;
 815     break;
 816   case SWIG_TypeError:
 817     type = PyExc_TypeError;
 818     break;
 819   case SWIG_DivisionByZero:
 820     type = PyExc_ZeroDivisionError;
 821     break;
 822   case SWIG_OverflowError:
 823     type = PyExc_OverflowError;
 824     break;
 825   case SWIG_SyntaxError:
 826     type = PyExc_SyntaxError;
 827     break;
 828   case SWIG_ValueError:
 829     type = PyExc_ValueError;
 830     break;
 831   case SWIG_SystemError:
 832     type = PyExc_SystemError;
 833     break;
 834   case SWIG_AttributeError:
 835     type = PyExc_AttributeError;
 836     break;
 837   default:
 838     type = PyExc_RuntimeError;
 839   }
 840   return type;
 841 }
 842
 843
 844 SWIGRUNTIME void
 845 SWIG_Python_AddErrorMsg(const char* mesg)
 846 {
 847   PyObject *type = 0;
 848   PyObject *value = 0;
 849   PyObject *traceback = 0;
 850
 851   if (PyErr_Occurred()) PyErr_Fetch(&type, &value, &traceback);
 852   if (value) {
 853     PyObject *old_str = PyObject_Str(value);
 854     PyErr_Clear();
 855     Py_XINCREF(type);
 856     PyErr_Format(type, "%s %s", PyString_AsString(old_str), mesg);
 857     Py_DECREF(old_str);
 858     Py_DECREF(value);
 859   } else {
 860     PyErr_SetString(PyExc_RuntimeError, mesg);
 861   }
 862 }
 863
 864
 865
 866 #if defined(SWIG_PYTHON_NO_THREADS)
 867 #  if defined(SWIG_PYTHON_THREADS)
 868 #    undef SWIG_PYTHON_THREADS
 869 #  endif
 870 #endif
 871 #if defined(SWIG_PYTHON_THREADS) /* Threading support is enabled */
 872 #  if !defined(SWIG_PYTHON_USE_GIL) && !defined(SWIG_PYTHON_NO_USE_GIL)
 873 #    if (PY_VERSION_HEX >= 0x02030000) /* For 2.3 or later, use the PyGILState calls */
 874 #      define SWIG_PYTHON_USE_GIL
 875 #    endif
 876 #  endif
 877 #  if defined(SWIG_PYTHON_USE_GIL) /* Use PyGILState threads calls */
 878 #    ifndef SWIG_PYTHON_INITIALIZE_THREADS
 879 #     define SWIG_PYTHON_INITIALIZE_THREADS  PyEval_InitThreads()
 880 #    endif
 881 #    ifdef __cplusplus /* C++ code */
 882        class SWIG_Python_Thread_Block {
 883          bool status;
 884          PyGILState_STATE state;
 885        public:
 886          void end() { if (status) { PyGILState_Release(state); status = false;} }
 887          SWIG_Python_Thread_Block() : status(true), state(PyGILState_Ensure()) {}
 888          ~SWIG_Python_Thread_Block() { end(); }
 889        };
 890        class SWIG_Python_Thread_Allow {
 891          bool status;
 892          PyThreadState *save;
 893        public:
 894          void end() { if (status) { PyEval_RestoreThread(save); status = false; }}
 895          SWIG_Python_Thread_Allow() : status(true), save(PyEval_SaveThread()) {}
 896          ~SWIG_Python_Thread_Allow() { end(); }
 897        };
 898 #      define SWIG_PYTHON_THREAD_BEGIN_BLOCK   SWIG_Python_Thread_Block _swig_thread_block
 899 #      define SWIG_PYTHON_THREAD_END_BLOCK     _swig_thread_block.end()
 900 #      define SWIG_PYTHON_THREAD_BEGIN_ALLOW   SWIG_Python_Thread_Allow _swig_thread_allow
 901 #      define SWIG_PYTHON_THREAD_END_ALLOW     _swig_thread_allow.end()
 902 #    else /* C code */
 903 #      define SWIG_PYTHON_THREAD_BEGIN_BLOCK   PyGILState_STATE _swig_thread_block = PyGILState_Ensure()
 904 #      define SWIG_PYTHON_THREAD_END_BLOCK     PyGILState_Release(_swig_thread_block)
 905 #      define SWIG_PYTHON_THREAD_BEGIN_ALLOW   PyThreadState *_swig_thread_allow = PyEval_SaveThread()
 906 #      define SWIG_PYTHON_THREAD_END_ALLOW     PyEval_RestoreThread(_swig_thread_allow)
 907 #    endif
 908 #  else /* Old thread way, not implemented, user must provide it */
 909 #    if !defined(SWIG_PYTHON_INITIALIZE_THREADS)
 910 #      define SWIG_PYTHON_INITIALIZE_THREADS
 911 #    endif
 912 #    if !defined(SWIG_PYTHON_THREAD_BEGIN_BLOCK)
 913 #      define SWIG_PYTHON_THREAD_BEGIN_BLOCK
 914 #    endif
 915 #    if !defined(SWIG_PYTHON_THREAD_END_BLOCK)
 916 #      define SWIG_PYTHON_THREAD_END_BLOCK
 917 #    endif
 918 #    if !defined(SWIG_PYTHON_THREAD_BEGIN_ALLOW)
 919 #      define SWIG_PYTHON_THREAD_BEGIN_ALLOW
 920 #    endif
 921 #    if !defined(SWIG_PYTHON_THREAD_END_ALLOW)
 922 #      define SWIG_PYTHON_THREAD_END_ALLOW
 923 #    endif
 924 #  endif
 925 #else /* No thread support */
 926 #  define SWIG_PYTHON_INITIALIZE_THREADS
 927 #  define SWIG_PYTHON_THREAD_BEGIN_BLOCK
 928 #  define SWIG_PYTHON_THREAD_END_BLOCK
 929 #  define SWIG_PYTHON_THREAD_BEGIN_ALLOW
 930 #  define SWIG_PYTHON_THREAD_END_ALLOW
 931 #endif
 932
 933 /* -----------------------------------------------------------------------------
 934  * Python API portion that goes into the runtime
 935  * ----------------------------------------------------------------------------- */
 936
 937 #ifdef __cplusplus
 938 extern "C" {
 939 #if 0
 940 } /* cc-mode */
 941 #endif
 942 #endif
 943
 944 /* -----------------------------------------------------------------------------
 945  * Constant declarations
 946  * ----------------------------------------------------------------------------- */
 947
 948 /* Constant Types */
 949 #define SWIG_PY_POINTER 4
 950 #define SWIG_PY_BINARY  5
 951
 952 /* Constant information structure */
 953 typedef struct swig_const_info {
 954   int type;
 955   char *name;
 956   long lvalue;
 957   double dvalue;
 958   void   *pvalue;
 959   swig_type_info **ptype;
 960 } swig_const_info;
 961
 962 #ifdef __cplusplus
 963 #if 0
 964 { /* cc-mode */
 965 #endif
 966 }
 967 #endif
 968
 969
 970 /* -----------------------------------------------------------------------------
 971  * See the LICENSE file for information on copyright, usage and redistribution
 972  * of SWIG, and the README file for authors - http://www.swig.org/release.html.
 973  *
 974  * pyrun.swg
 975  *
 976  * This file contains the runtime support for Python modules
 977  * and includes code for managing global variables and pointer
 978  * type checking.
 979  *
 980  * ----------------------------------------------------------------------------- */
 981
 982 /* Common SWIG API */
 983
 984 /* for raw pointers */
 985 #define SWIG_Python_ConvertPtr(obj, pptr, type, flags)  SWIG_Python_ConvertPtrAndOwn(obj, pptr, type, flags, 0)
 986 #define SWIG_ConvertPtr(obj, pptr, type, flags)         SWIG_Python_ConvertPtr(obj, pptr, type, flags)
 987 #define SWIG_ConvertPtrAndOwn(obj,pptr,type,flags,own)  SWIG_Python_ConvertPtrAndOwn(obj, pptr, type, flags, own)
 988 #define SWIG_NewPointerObj(ptr, type, flags)            SWIG_Python_NewPointerObj(ptr, type, flags)
 989 #define SWIG_CheckImplicit(ty)                          SWIG_Python_CheckImplicit(ty)
 990 #define SWIG_AcquirePtr(ptr, src)                       SWIG_Python_AcquirePtr(ptr, src)
 991 #define swig_owntype                                    int
 992
 993 /* for raw packed data */
 994 #define SWIG_ConvertPacked(obj, ptr, sz, ty)            SWIG_Python_ConvertPacked(obj, ptr, sz, ty)
 995 #define SWIG_NewPackedObj(ptr, sz, type)                SWIG_Python_NewPackedObj(ptr, sz, type)
 996
 997 /* for class or struct pointers */
 998 #define SWIG_ConvertInstance(obj, pptr, type, flags)    SWIG_ConvertPtr(obj, pptr, type, flags)
 999 #define SWIG_NewInstanceObj(ptr, type, flags)           SWIG_NewPointerObj(ptr, type, flags)
1000
1001 /* for C or C++ function pointers */
1002 #define SWIG_ConvertFunctionPtr(obj, pptr, type)        SWIG_Python_ConvertFunctionPtr(obj, pptr, type)
1003 #define SWIG_NewFunctionPtrObj(ptr, type)               SWIG_Python_NewPointerObj(ptr, type, 0)
1004
1005 /* for C++ member pointers, ie, member methods */
1006 #define SWIG_ConvertMember(obj, ptr, sz, ty)            SWIG_Python_ConvertPacked(obj, ptr, sz, ty)
1007 #define SWIG_NewMemberObj(ptr, sz, type)                SWIG_Python_NewPackedObj(ptr, sz, type)
1008
1009
1010 /* Runtime API */
1011
1012 #define SWIG_GetModule(clientdata)                      SWIG_Python_GetModule()
1013 #define SWIG_SetModule(clientdata, pointer)             SWIG_Python_SetModule(pointer)
1014 #define SWIG_NewClientData(obj)                         PySwigClientData_New(obj)
1015
1016 #define SWIG_SetErrorObj                                SWIG_Python_SetErrorObj
1017 #define SWIG_SetErrorMsg                                SWIG_Python_SetErrorMsg
1018 #define SWIG_ErrorType(code)                            SWIG_Python_ErrorType(code)
1019 #define SWIG_Error(code, msg)                           SWIG_Python_SetErrorMsg(SWIG_ErrorType(code), msg)
1020 #define SWIG_fail                                       goto fail
1021
1022
1023 /* Runtime API implementation */
1024
1025 /* Error manipulation */
1026
1027 SWIGINTERN void
1028 SWIG_Python_SetErrorObj(PyObject *errtype, PyObject *obj) {
1029   SWIG_PYTHON_THREAD_BEGIN_BLOCK;
1030   PyErr_SetObject(errtype, obj);
1031   Py_DECREF(obj);
1032   SWIG_PYTHON_THREAD_END_BLOCK;
1033 }
1034
1035 SWIGINTERN void
1036 SWIG_Python_SetErrorMsg(PyObject *errtype, const char *msg) {
1037   SWIG_PYTHON_THREAD_BEGIN_BLOCK;
1038   PyErr_SetString(errtype, (char *) msg);
1039   SWIG_PYTHON_THREAD_END_BLOCK;
1040 }
1041
1042 #define SWIG_Python_Raise(obj, type, desc)  SWIG_Python_SetErrorObj(SWIG_Python_ExceptionType(desc), obj)
1043
1044 /* Set a constant value */
1045
1046 SWIGINTERN void
1047 SWIG_Python_SetConstant(PyObject *d, const char *name, PyObject *obj) {
1048   PyDict_SetItemString(d, (char*) name, obj);
1049   Py_DECREF(obj);
1050 }
1051
1052 /* Append a value to the result obj */
1053
1054 SWIGINTERN PyObject*
1055 SWIG_Python_AppendOutput(PyObject* result, PyObject* obj) {
1056 #if !defined(SWIG_PYTHON_OUTPUT_TUPLE)
1057   if (!result) {
1058     result = obj;
1059   } else if (result == Py_None) {
1060     Py_DECREF(result);
1061     result = obj;
1062   } else {
1063     if (!PyList_Check(result)) {
1064       PyObject *o2 = result;
1065       result = PyList_New(1);
1066       PyList_SetItem(result, 0, o2);
1067     }
1068     PyList_Append(result,obj);
1069     Py_DECREF(obj);
1070   }
1071   return result;
1072 #else
1073   PyObject*   o2;
1074   PyObject*   o3;
1075   if (!result) {
1076     result = obj;
1077   } else if (result == Py_None) {
1078     Py_DECREF(result);
1079     result = obj;
1080   } else {
1081     if (!PyTuple_Check(result)) {
1082       o2 = result;
1083       result = PyTuple_New(1);
1084       PyTuple_SET_ITEM(result, 0, o2);
1085     }
1086     o3 = PyTuple_New(1);
1087     PyTuple_SET_ITEM(o3, 0, obj);
1088     o2 = result;
1089     result = PySequence_Concat(o2, o3);
1090     Py_DECREF(o2);
1091     Py_DECREF(o3);
1092   }
1093   return result;
1094 #endif
1095 }
1096
1097 /* Unpack the argument tuple */
1098
1099 SWIGINTERN int
1100 SWIG_Python_UnpackTuple(PyObject *args, const char *name, Py_ssize_t min, Py_ssize_t max, PyObject **objs)
1101 {
1102   if (!args) {
1103     if (!min && !max) {
1104       return 1;
1105     } else {
1106       PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got none",
1107                    name, (min == max ? "" : "at least "), (int)min);
1108       return 0;
1109     }
1110   }
1111   if (!PyTuple_Check(args)) {
1112     PyErr_SetString(PyExc_SystemError, "UnpackTuple() argument list is not a tuple");
1113     return 0;
1114   } else {
1115     register Py_ssize_t l = PyTuple_GET_SIZE(args);
1116     if (l < min) {
1117       PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got %d",
1118                    name, (min == max ? "" : "at least "), (int)min, (int)l);
1119       return 0;
1120     } else if (l > max) {
1121       PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got %d",
1122                    name, (min == max ? "" : "at most "), (int)max, (int)l);
1123       return 0;
1124     } else {
1125       register int i;
1126       for (i = 0; i < l; ++i) {
1127         objs[i] = PyTuple_GET_ITEM(args, i);
1128       }
1129       for (; l < max; ++l) {
1130         objs[l] = 0;
1131       }
1132       return i + 1;
1133     }
1134   }
1135 }
1136
1137 /* A functor is a function object with one single object argument */
1138 #if PY_VERSION_HEX >= 0x02020000
1139 #define SWIG_Python_CallFunctor(functor, obj)           PyObject_CallFunctionObjArgs(functor, obj, NULL);
1140 #else
1141 #define SWIG_Python_CallFunctor(functor, obj)           PyObject_CallFunction(functor, "O", obj);
1142 #endif
1143
1144 /*
1145   Helper for static pointer initialization for both C and C++ code, for example
1146   static PyObject *SWIG_STATIC_POINTER(MyVar) = NewSomething(...);
1147 */
1148 #ifdef __cplusplus
1149 #define SWIG_STATIC_POINTER(var)  var
1150 #else
1151 #define SWIG_STATIC_POINTER(var)  var = 0; if (!var) var
1152 #endif
1153
1154 /* -----------------------------------------------------------------------------
1155  * Pointer declarations
1156  * ----------------------------------------------------------------------------- */
1157
1158 /* Flags for new pointer objects */
1159 #define SWIG_POINTER_NOSHADOW       (SWIG_POINTER_OWN      << 1)
1160 #define SWIG_POINTER_NEW            (SWIG_POINTER_NOSHADOW | SWIG_POINTER_OWN)
1161
1162 #define SWIG_POINTER_IMPLICIT_CONV  (SWIG_POINTER_DISOWN   << 1)
1163
1164 #ifdef __cplusplus
1165 extern "C" {
1166 #if 0
1167 } /* cc-mode */
1168 #endif
1169 #endif
1170
1171 /*  How to access Py_None */
1172 #if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
1173 #  ifndef SWIG_PYTHON_NO_BUILD_NONE
1174 #    ifndef SWIG_PYTHON_BUILD_NONE
1175 #      define SWIG_PYTHON_BUILD_NONE
1176 #    endif
1177 #  endif
1178 #endif
1179
1180 #ifdef SWIG_PYTHON_BUILD_NONE
1181 #  ifdef Py_None
1182 #   undef Py_None
1183 #   define Py_None SWIG_Py_None()
1184 #  endif
1185 SWIGRUNTIMEINLINE PyObject *
1186 _SWIG_Py_None(void)
1187 {
1188   PyObject *none = Py_BuildValue((char*)"");
1189   Py_DECREF(none);
1190   return none;
1191 }
1192 SWIGRUNTIME PyObject *
1193 SWIG_Py_None(void)
1194 {
1195   static PyObject *SWIG_STATIC_POINTER(none) = _SWIG_Py_None();
1196   return none;
1197 }
1198 #endif
1199
1200 /* The python void return value */
1201
1202 SWIGRUNTIMEINLINE PyObject *
1203 SWIG_Py_Void(void)
1204 {
1205   PyObject *none = Py_None;
1206   Py_INCREF(none);
1207   return none;
1208 }
1209
1210 /* PySwigClientData */
1211
1212 typedef struct {
1213   PyObject *klass;
1214   PyObject *newraw;
1215   PyObject *newargs;
1216   PyObject *destroy;
1217   int delargs;
1218   int implicitconv;
1219 } PySwigClientData;
1220
1221 SWIGRUNTIMEINLINE int
1222 SWIG_Python_CheckImplicit(swig_type_info *ty)
1223 {
1224   PySwigClientData *data = (PySwigClientData *)ty->clientdata;
1225   return data ? data->implicitconv : 0;
1226 }
1227
1228 SWIGRUNTIMEINLINE PyObject *
1229 SWIG_Python_ExceptionType(swig_type_info *desc) {
1230   PySwigClientData *data = desc ? (PySwigClientData *) desc->clientdata : 0;
1231   PyObject *klass = data ? data->klass : 0;
1232   return (klass ? klass : PyExc_RuntimeError);
1233 }
1234
1235
1236 SWIGRUNTIME PySwigClientData *
1237 PySwigClientData_New(PyObject* obj)
1238 {
1239   if (!obj) {
1240     return 0;
1241   } else {
1242     PySwigClientData *data = (PySwigClientData *)malloc(sizeof(PySwigClientData));
1243     /* the klass element */
1244     data->klass = obj;
1245     Py_INCREF(data->klass);
1246     /* the newraw method and newargs arguments used to create a new raw instance */
1247     if (PyClass_Check(obj)) {
1248       data->newraw = 0;
1249       data->newargs = obj;
1250       Py_INCREF(obj);
1251     } else {
1252 #if (PY_VERSION_HEX < 0x02020000)
1253       data->newraw = 0;
1254 #else
1255       data->newraw = PyObject_GetAttrString(data->klass, (char *)"__new__");
1256 #endif
1257       if (data->newraw) {
1258         Py_INCREF(data->newraw);
1259         data->newargs = PyTuple_New(1);
1260         PyTuple_SetItem(data->newargs, 0, obj);
1261       } else {
1262         data->newargs = obj;
1263       }
1264       Py_INCREF(data->newargs);
1265     }
1266     /* the destroy method, aka as the C++ delete method */
1267     data->destroy = PyObject_GetAttrString(data->klass, (char *)"__swig_destroy__");
1268     if (PyErr_Occurred()) {
1269       PyErr_Clear();
1270       data->destroy = 0;
1271     }
1272     if (data->destroy) {
1273       int flags;
1274       Py_INCREF(data->destroy);
1275       flags = PyCFunction_GET_FLAGS(data->destroy);
1276 #ifdef METH_O
1277       data->delargs = !(flags & (METH_O));
1278 #else
1279       data->delargs = 0;
1280 #endif
1281     } else {
1282       data->delargs = 0;
1283     }
1284     data->implicitconv = 0;
1285     return data;
1286   }
1287 }
1288
1289 SWIGRUNTIME void
1290 PySwigClientData_Del(PySwigClientData* data)
1291 {
1292   Py_XDECREF(data->newraw);
1293   Py_XDECREF(data->newargs);
1294   Py_XDECREF(data->destroy);
1295 }
1296
1297 /* =============== PySwigObject =====================*/
1298
1299 typedef struct {
1300   PyObject_HEAD
1301   void *ptr;
1302   swig_type_info *ty;
1303   int own;
1304   PyObject *next;
1305 } PySwigObject;
1306
1307 SWIGRUNTIME PyObject *
1308 PySwigObject_long(PySwigObject *v)
1309 {
1310   return PyLong_FromVoidPtr(v->ptr);
1311 }
1312
1313 SWIGRUNTIME PyObject *
1314 PySwigObject_format(const char* fmt, PySwigObject *v)
1315 {
1316   PyObject *res = NULL;
1317   PyObject *args = PyTuple_New(1);
1318   if (args) {
1319     if (PyTuple_SetItem(args, 0, PySwigObject_long(v)) == 0) {
1320       PyObject *ofmt = PyString_FromString(fmt);
1321       if (ofmt) {
1322         res = PyString_Format(ofmt,args);
1323         Py_DECREF(ofmt);
1324       }
1325       Py_DECREF(args);
1326     }
1327   }
1328   return res;
1329 }
1330
1331 SWIGRUNTIME PyObject *
1332 PySwigObject_oct(PySwigObject *v)
1333 {
1334   return PySwigObject_format("%o",v);
1335 }
1336
1337 SWIGRUNTIME PyObject *
1338 PySwigObject_hex(PySwigObject *v)
1339 {
1340   return PySwigObject_format("%x",v);
1341 }
1342
1343 SWIGRUNTIME PyObject *
1344 #ifdef METH_NOARGS
1345 PySwigObject_repr(PySwigObject *v)
1346 #else
1347 PySwigObject_repr(PySwigObject *v, PyObject *args)
1348 #endif
1349 {
1350   const char *name = SWIG_TypePrettyName(v->ty);
1351   PyObject *hex = PySwigObject_hex(v);
1352   PyObject *repr = PyString_FromFormat("<Swig Object of type '%s' at 0x%s>", name, PyString_AsString(hex));
1353   Py_DECREF(hex);
1354   if (v->next) {
1355 #ifdef METH_NOARGS
1356     PyObject *nrep = PySwigObject_repr((PySwigObject *)v->next);
1357 #else
1358     PyObject *nrep = PySwigObject_repr((PySwigObject *)v->next, args);
1359 #endif
1360     PyString_ConcatAndDel(&repr,nrep);
1361   }
1362   return repr;
1363 }
1364
1365 SWIGRUNTIME int
1366 PySwigObject_print(PySwigObject *v, FILE *fp, int SWIGUNUSEDPARM(flags))
1367 {
1368 #ifdef METH_NOARGS
1369   PyObject *repr = PySwigObject_repr(v);
1370 #else
1371   PyObject *repr = PySwigObject_repr(v, NULL);
1372 #endif
1373   if (repr) {
1374     fputs(PyString_AsString(repr), fp);
1375     Py_DECREF(repr);
1376     return 0;
1377   } else {
1378     return 1;
1379   }
1380 }
1381
1382 SWIGRUNTIME PyObject *
1383 PySwigObject_str(PySwigObject *v)
1384 {
1385   char result[SWIG_BUFFER_SIZE];
1386   return SWIG_PackVoidPtr(result, v->ptr, v->ty->name, sizeof(result)) ?
1387     PyString_FromString(result) : 0;
1388 }
1389
1390 SWIGRUNTIME int
1391 PySwigObject_compare(PySwigObject *v, PySwigObject *w)
1392 {
1393   void *i = v->ptr;
1394   void *j = w->ptr;
1395   return (i < j) ? -1 : ((i > j) ? 1 : 0);
1396 }
1397
1398 SWIGRUNTIME PyTypeObject* _PySwigObject_type(void);
1399
1400 SWIGRUNTIME PyTypeObject*
1401 PySwigObject_type(void) {
1402   static PyTypeObject *SWIG_STATIC_POINTER(type) = _PySwigObject_type();
1403   return type;
1404 }
1405
1406 SWIGRUNTIMEINLINE int
1407 PySwigObject_Check(PyObject *op) {
1408   return ((op)->ob_type == PySwigObject_type())
1409     || (strcmp((op)->ob_type->tp_name,"PySwigObject") == 0);
1410 }
1411
1412 SWIGRUNTIME PyObject *
1413 PySwigObject_New(void *ptr, swig_type_info *ty, int own);
1414
1415 SWIGRUNTIME void
1416 PySwigObject_dealloc(PyObject *v)
1417 {
1418   PySwigObject *sobj = (PySwigObject *) v;
1419   PyObject *next = sobj->next;
1420   if (sobj->own == SWIG_POINTER_OWN) {
1421     swig_type_info *ty = sobj->ty;
1422     PySwigClientData *data = ty ? (PySwigClientData *) ty->clientdata : 0;
1423     PyObject *destroy = data ? data->destroy : 0;
1424     if (destroy) {
1425       /* destroy is always a VARARGS method */
1426       PyObject *res;
1427       if (data->delargs) {
1428         /* we need to create a temporal object to carry the destroy operation */
1429         PyObject *tmp = PySwigObject_New(sobj->ptr, ty, 0);
1430         res = SWIG_Python_CallFunctor(destroy, tmp);
1431         Py_DECREF(tmp);
1432       } else {
1433         PyCFunction meth = PyCFunction_GET_FUNCTION(destroy);
1434         PyObject *mself = PyCFunction_GET_SELF(destroy);
1435         res = ((*meth)(mself, v));
1436       }
1437       Py_XDECREF(res);
1438     }
1439 #if !defined(SWIG_PYTHON_SILENT_MEMLEAK)
1440     else {
1441       const char *name = SWIG_TypePrettyName(ty);
1442       printf("swig/python detected a memory leak of type '%s', no destructor found.\n", (name ? name : "unknown"));
1443     }
1444 #endif
1445   }
1446   Py_XDECREF(next);
1447   PyObject_DEL(v);
1448 }
1449
1450 SWIGRUNTIME PyObject*
1451 PySwigObject_append(PyObject* v, PyObject* next)
1452 {
1453   PySwigObject *sobj = (PySwigObject *) v;
1454 #ifndef METH_O
1455   PyObject *tmp = 0;
1456   if (!PyArg_ParseTuple(next,(char *)"O:append", &tmp)) return NULL;
1457   next = tmp;
1458 #endif
1459   if (!PySwigObject_Check(next)) {
1460     return NULL;
1461   }
1462   sobj->next = next;
1463   Py_INCREF(next);
1464   return SWIG_Py_Void();
1465 }
1466
1467 SWIGRUNTIME PyObject*
1468 #ifdef METH_NOARGS
1469 PySwigObject_next(PyObject* v)
1470 #else
1471 PySwigObject_next(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
1472 #endif
1473 {
1474   PySwigObject *sobj = (PySwigObject *) v;
1475   if (sobj->next) {
1476     Py_INCREF(sobj->next);
1477     return sobj->next;
1478   } else {
1479     return SWIG_Py_Void();
1480   }
1481 }
1482
1483 SWIGINTERN PyObject*
1484 #ifdef METH_NOARGS
1485 PySwigObject_disown(PyObject *v)
1486 #else
1487 PySwigObject_disown(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
1488 #endif
1489 {
1490   PySwigObject *sobj = (PySwigObject *)v;
1491   sobj->own = 0;
1492   return SWIG_Py_Void();
1493 }
1494
1495 SWIGINTERN PyObject*
1496 #ifdef METH_NOARGS
1497 PySwigObject_acquire(PyObject *v)
1498 #else
1499 PySwigObject_acquire(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
1500 #endif
1501 {
1502   PySwigObject *sobj = (PySwigObject *)v;
1503   sobj->own = SWIG_POINTER_OWN;
1504   return SWIG_Py_Void();
1505 }
1506
1507 SWIGINTERN PyObject*
1508 PySwigObject_own(PyObject *v, PyObject *args)
1509 {
1510   PyObject *val = 0;
1511 #if (PY_VERSION_HEX < 0x02020000)
1512   if (!PyArg_ParseTuple(args,(char *)"|O:own",&val))
1513 #else
1514   if (!PyArg_UnpackTuple(args, (char *)"own", 0, 1, &val))
1515 #endif
1516     {
1517       return NULL;
1518     }
1519   else
1520     {
1521       PySwigObject *sobj = (PySwigObject *)v;
1522       PyObject *obj = PyBool_FromLong(sobj->own);
1523       if (val) {
1524 #ifdef METH_NOARGS
1525         if (PyObject_IsTrue(val)) {
1526           PySwigObject_acquire(v);
1527         } else {
1528           PySwigObject_disown(v);
1529         }
1530 #else
1531         if (PyObject_IsTrue(val)) {
1532           PySwigObject_acquire(v,args);
1533         } else {
1534           PySwigObject_disown(v,args);
1535         }
1536 #endif
1537       }
1538       return obj;
1539     }
1540 }
1541
1542 #ifdef METH_O
1543 static PyMethodDef
1544 swigobject_methods[] = {
1545   {(char *)"disown",  (PyCFunction)PySwigObject_disown,  METH_NOARGS,  (char *)"releases ownership of the pointer"},
1546   {(char *)"acquire", (PyCFunction)PySwigObject_acquire, METH_NOARGS,  (char *)"aquires ownership of the pointer"},
1547   {(char *)"own",     (PyCFunction)PySwigObject_own,     METH_VARARGS, (char *)"returns/sets ownership of the pointer"},
1548   {(char *)"append",  (PyCFunction)PySwigObject_append,  METH_O,       (char *)"appends another 'this' object"},
1549   {(char *)"next",    (PyCFunction)PySwigObject_next,    METH_NOARGS,  (char *)"returns the next 'this' object"},
1550   {(char *)"__repr__",(PyCFunction)PySwigObject_repr,    METH_NOARGS,  (char *)"returns object representation"},
1551   {0, 0, 0, 0}
1552 };
1553 #else
1554 static PyMethodDef
1555 swigobject_methods[] = {
1556   {(char *)"disown",  (PyCFunction)PySwigObject_disown,  METH_VARARGS,  (char *)"releases ownership of the pointer"},
1557   {(char *)"acquire", (PyCFunction)PySwigObject_acquire, METH_VARARGS,  (char *)"aquires ownership of the pointer"},
1558   {(char *)"own",     (PyCFunction)PySwigObject_own,     METH_VARARGS,  (char *)"returns/sets ownership of the pointer"},
1559   {(char *)"append",  (PyCFunction)PySwigObject_append,  METH_VARARGS,  (char *)"appends another 'this' object"},
1560   {(char *)"next",    (PyCFunction)PySwigObject_next,    METH_VARARGS,  (char *)"returns the next 'this' object"},
1561   {(char *)"__repr__",(PyCFunction)PySwigObject_repr,   METH_VARARGS,  (char *)"returns object representation"},
1562   {0, 0, 0, 0}
1563 };
1564 #endif
1565
1566 #if PY_VERSION_HEX < 0x02020000
1567 SWIGINTERN PyObject *
1568 PySwigObject_getattr(PySwigObject *sobj,char *name)
1569 {
1570   return Py_FindMethod(swigobject_methods, (PyObject *)sobj, name);
1571 }
1572 #endif
1573
1574 SWIGRUNTIME PyTypeObject*
1575 _PySwigObject_type(void) {
1576   static char swigobject_doc[] = "Swig object carries a C/C++ instance pointer";
1577
1578   static PyNumberMethods PySwigObject_as_number = {
1579     (binaryfunc)0, /*nb_add*/
1580     (binaryfunc)0, /*nb_subtract*/
1581     (binaryfunc)0, /*nb_multiply*/
1582     (binaryfunc)0, /*nb_divide*/
1583     (binaryfunc)0, /*nb_remainder*/
1584     (binaryfunc)0, /*nb_divmod*/
1585     (ternaryfunc)0,/*nb_power*/
1586     (unaryfunc)0,  /*nb_negative*/
1587     (unaryfunc)0,  /*nb_positive*/
1588     (unaryfunc)0,  /*nb_absolute*/
1589     (inquiry)0,    /*nb_nonzero*/
1590     0,             /*nb_invert*/
1591     0,             /*nb_lshift*/
1592     0,             /*nb_rshift*/
1593     0,             /*nb_and*/
1594     0,             /*nb_xor*/
1595     0,             /*nb_or*/
1596     (coercion)0,   /*nb_coerce*/
1597     (unaryfunc)PySwigObject_long, /*nb_int*/
1598     (unaryfunc)PySwigObject_long, /*nb_long*/
1599     (unaryfunc)0,                 /*nb_float*/
1600     (unaryfunc)PySwigObject_oct,  /*nb_oct*/
1601     (unaryfunc)PySwigObject_hex,  /*nb_hex*/
1602 #if PY_VERSION_HEX >= 0x02050000 /* 2.5.0 */
1603     0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_index */
1604 #elif PY_VERSION_HEX >= 0x02020000 /* 2.2.0 */
1605     0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_true_divide */
1606 #elif PY_VERSION_HEX >= 0x02000000 /* 2.0.0 */
1607     0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_or */
1608 #endif
1609   };
1610
1611   static PyTypeObject pyswigobject_type;
1612   static int type_init = 0;
1613   if (!type_init) {
1614     const PyTypeObject tmp
1615       = {
1616         PyObject_HEAD_INIT(NULL)
1617         0,                                  /* ob_size */
1618         (char *)"PySwigObject",             /* tp_name */
1619         sizeof(PySwigObject),               /* tp_basicsize */
1620         0,                                  /* tp_itemsize */
1621         (destructor)PySwigObject_dealloc,   /* tp_dealloc */
1622         (printfunc)PySwigObject_print,      /* tp_print */
1623 #if PY_VERSION_HEX < 0x02020000
1624         (getattrfunc)PySwigObject_getattr,  /* tp_getattr */
1625 #else
1626         (getattrfunc)0,                     /* tp_getattr */
1627 #endif
1628         (setattrfunc)0,                     /* tp_setattr */
1629         (cmpfunc)PySwigObject_compare,      /* tp_compare */
1630         (reprfunc)PySwigObject_repr,        /* tp_repr */
1631         &PySwigObject_as_number,            /* tp_as_number */
1632         0,                                  /* tp_as_sequence */
1633         0,                                  /* tp_as_mapping */
1634         (hashfunc)0,                        /* tp_hash */
1635         (ternaryfunc)0,                     /* tp_call */
1636         (reprfunc)PySwigObject_str,         /* tp_str */
1637         PyObject_GenericGetAttr,            /* tp_getattro */
1638         0,                                  /* tp_setattro */
1639         0,                                  /* tp_as_buffer */
1640         Py_TPFLAGS_DEFAULT,                 /* tp_flags */
1641         swigobject_doc,                     /* tp_doc */
1642         0,                                  /* tp_traverse */
1643         0,                                  /* tp_clear */
1644         0,                                  /* tp_richcompare */
1645         0,                                  /* tp_weaklistoffset */
1646 #if PY_VERSION_HEX >= 0x02020000
1647         0,                                  /* tp_iter */
1648         0,                                  /* tp_iternext */
1649         swigobject_methods,                 /* tp_methods */
1650         0,                                  /* tp_members */
1651         0,                                  /* tp_getset */
1652         0,                                  /* tp_base */
1653         0,                                  /* tp_dict */
1654         0,                                  /* tp_descr_get */
1655         0,                                  /* tp_descr_set */
1656         0,                                  /* tp_dictoffset */
1657         0,                                  /* tp_init */
1658         0,                                  /* tp_alloc */
1659         0,                                  /* tp_new */
1660         0,                                  /* tp_free */
1661         0,                                  /* tp_is_gc */
1662         0,                                  /* tp_bases */
1663         0,                                  /* tp_mro */
1664         0,                                  /* tp_cache */
1665         0,                                  /* tp_subclasses */
1666         0,                                  /* tp_weaklist */
1667 #endif
1668 #if PY_VERSION_HEX >= 0x02030000
1669         0,                                  /* tp_del */
1670 #endif
1671 #ifdef COUNT_ALLOCS
1672         0,0,0,0                             /* tp_alloc -> tp_next */
1673 #endif
1674       };
1675     pyswigobject_type = tmp;
1676     pyswigobject_type.ob_type = &PyType_Type;
1677     type_init = 1;
1678   }
1679   return &pyswigobject_type;
1680 }
1681
1682 SWIGRUNTIME PyObject *
1683 PySwigObject_New(void *ptr, swig_type_info *ty, int own)
1684 {
1685   PySwigObject *sobj = PyObject_NEW(PySwigObject, PySwigObject_type());
1686   if (sobj) {
1687     sobj->ptr  = ptr;
1688     sobj->ty   = ty;
1689     sobj->own  = own;
1690     sobj->next = 0;
1691   }
1692   return (PyObject *)sobj;
1693 }
1694
1695 /* -----------------------------------------------------------------------------
1696  * Implements a simple Swig Packed type, and use it instead of string
1697  * ----------------------------------------------------------------------------- */
1698
1699 typedef struct {
1700   PyObject_HEAD
1701   void *pack;
1702   swig_type_info *ty;
1703   size_t size;
1704 } PySwigPacked;
1705
1706 SWIGRUNTIME int
1707 PySwigPacked_print(PySwigPacked *v, FILE *fp, int SWIGUNUSEDPARM(flags))
1708 {
1709   char result[SWIG_BUFFER_SIZE];
1710   fputs("<Swig Packed ", fp);
1711   if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
1712     fputs("at ", fp);
1713     fputs(result, fp);
1714   }
1715   fputs(v->ty->name,fp);
1716   fputs(">", fp);
1717   return 0;
1718 }
1719
1720 SWIGRUNTIME PyObject *
1721 PySwigPacked_repr(PySwigPacked *v)
1722 {
1723   char result[SWIG_BUFFER_SIZE];
1724   if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
1725     return PyString_FromFormat("<Swig Packed at %s%s>", result, v->ty->name);
1726   } else {
1727     return PyString_FromFormat("<Swig Packed %s>", v->ty->name);
1728   }
1729 }
1730
1731 SWIGRUNTIME PyObject *
1732 PySwigPacked_str(PySwigPacked *v)
1733 {
1734   char result[SWIG_BUFFER_SIZE];
1735   if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))){
1736     return PyString_FromFormat("%s%s", result, v->ty->name);
1737   } else {
1738     return PyString_FromString(v->ty->name);
1739   }
1740 }
1741
1742 SWIGRUNTIME int
1743 PySwigPacked_compare(PySwigPacked *v, PySwigPacked *w)
1744 {
1745   size_t i = v->size;
1746   size_t j = w->size;
1747   int s = (i < j) ? -1 : ((i > j) ? 1 : 0);
1748   return s ? s : strncmp((char *)v->pack, (char *)w->pack, 2*v->size);
1749 }
1750
1751 SWIGRUNTIME PyTypeObject* _PySwigPacked_type(void);
1752
1753 SWIGRUNTIME PyTypeObject*
1754 PySwigPacked_type(void) {
1755   static PyTypeObject *SWIG_STATIC_POINTER(type) = _PySwigPacked_type();
1756   return type;
1757 }
1758
1759 SWIGRUNTIMEINLINE int
1760 PySwigPacked_Check(PyObject *op) {
1761   return ((op)->ob_type == _PySwigPacked_type())
1762     || (strcmp((op)->ob_type->tp_name,"PySwigPacked") == 0);
1763 }
1764
1765 SWIGRUNTIME void
1766 PySwigPacked_dealloc(PyObject *v)
1767 {
1768   if (PySwigPacked_Check(v)) {
1769     PySwigPacked *sobj = (PySwigPacked *) v;
1770     free(sobj->pack);
1771   }
1772   PyObject_DEL(v);
1773 }
1774
1775 SWIGRUNTIME PyTypeObject*
1776 _PySwigPacked_type(void) {
1777   static char swigpacked_doc[] = "Swig object carries a C/C++ instance pointer";
1778   static PyTypeObject pyswigpacked_type;
1779   static int type_init = 0;
1780   if (!type_init) {
1781     const PyTypeObject tmp
1782       = {
1783         PyObject_HEAD_INIT(NULL)
1784         0,                                  /* ob_size */
1785         (char *)"PySwigPacked",             /* tp_name */
1786         sizeof(PySwigPacked),               /* tp_basicsize */
1787         0,                                  /* tp_itemsize */
1788         (destructor)PySwigPacked_dealloc,   /* tp_dealloc */
1789         (printfunc)PySwigPacked_print,      /* tp_print */
1790         (getattrfunc)0,                     /* tp_getattr */
1791         (setattrfunc)0,                     /* tp_setattr */
1792         (cmpfunc)PySwigPacked_compare,      /* tp_compare */
1793         (reprfunc)PySwigPacked_repr,        /* tp_repr */
1794         0,                                  /* tp_as_number */
1795         0,                                  /* tp_as_sequence */
1796         0,                                  /* tp_as_mapping */
1797         (hashfunc)0,                        /* tp_hash */
1798         (ternaryfunc)0,                     /* tp_call */
1799         (reprfunc)PySwigPacked_str,         /* tp_str */
1800         PyObject_GenericGetAttr,            /* tp_getattro */
1801         0,                                  /* tp_setattro */
1802         0,                                  /* tp_as_buffer */
1803         Py_TPFLAGS_DEFAULT,                 /* tp_flags */
1804         swigpacked_doc,                     /* tp_doc */
1805         0,                                  /* tp_traverse */
1806         0,                                  /* tp_clear */
1807         0,                                  /* tp_richcompare */
1808         0,                                  /* tp_weaklistoffset */
1809 #if PY_VERSION_HEX >= 0x02020000
1810         0,                                  /* tp_iter */
1811         0,                                  /* tp_iternext */
1812         0,                                  /* tp_methods */
1813         0,                                  /* tp_members */
1814         0,                                  /* tp_getset */
1815         0,                                  /* tp_base */
1816         0,                                  /* tp_dict */
1817         0,                                  /* tp_descr_get */
1818         0,                                  /* tp_descr_set */
1819         0,                                  /* tp_dictoffset */
1820         0,                                  /* tp_init */
1821         0,                                  /* tp_alloc */
1822         0,                                  /* tp_new */
1823         0,                                  /* tp_free */
1824         0,                                  /* tp_is_gc */
1825         0,                                  /* tp_bases */
1826         0,                                  /* tp_mro */
1827         0,                                  /* tp_cache */
1828         0,                                  /* tp_subclasses */
1829         0,                                  /* tp_weaklist */
1830 #endif
1831 #if PY_VERSION_HEX >= 0x02030000
1832         0,                                  /* tp_del */
1833 #endif
1834 #ifdef COUNT_ALLOCS
1835         0,0,0,0                             /* tp_alloc -> tp_next */
1836 #endif
1837       };
1838     pyswigpacked_type = tmp;
1839     pyswigpacked_type.ob_type = &PyType_Type;
1840     type_init = 1;
1841   }
1842   return &pyswigpacked_type;
1843 }
1844
1845 SWIGRUNTIME PyObject *
1846 PySwigPacked_New(void *ptr, size_t size, swig_type_info *ty)
1847 {
1848   PySwigPacked *sobj = PyObject_NEW(PySwigPacked, PySwigPacked_type());
1849   if (sobj) {
1850     void *pack = malloc(size);
1851     if (pack) {
1852       memcpy(pack, ptr, size);
1853       sobj->pack = pack;
1854       sobj->ty   = ty;
1855       sobj->size = size;
1856     } else {
1857       PyObject_DEL((PyObject *) sobj);
1858       sobj = 0;
1859     }
1860   }
1861   return (PyObject *) sobj;
1862 }
1863
1864 SWIGRUNTIME swig_type_info *
1865 PySwigPacked_UnpackData(PyObject *obj, void *ptr, size_t size)
1866 {
1867   if (PySwigPacked_Check(obj)) {
1868     PySwigPacked *sobj = (PySwigPacked *)obj;
1869     if (sobj->size != size) return 0;
1870     memcpy(ptr, sobj->pack, size);
1871     return sobj->ty;
1872   } else {
1873     return 0;
1874   }
1875 }
1876
1877 /* -----------------------------------------------------------------------------
1878  * pointers/data manipulation
1879  * ----------------------------------------------------------------------------- */
1880
1881 SWIGRUNTIMEINLINE PyObject *
1882 _SWIG_This(void)
1883 {
1884   return PyString_FromString("this");
1885 }
1886
1887 SWIGRUNTIME PyObject *
1888 SWIG_This(void)
1889 {
1890   static PyObject *SWIG_STATIC_POINTER(swig_this) = _SWIG_This();
1891   return swig_this;
1892 }
1893
1894 /* #define SWIG_PYTHON_SLOW_GETSET_THIS */
1895
1896 SWIGRUNTIME PySwigObject *
1897 SWIG_Python_GetSwigThis(PyObject *pyobj)
1898 {
1899   if (PySwigObject_Check(pyobj)) {
1900     return (PySwigObject *) pyobj;
1901   } else {
1902     PyObject *obj = 0;
1903 #if (!defined(SWIG_PYTHON_SLOW_GETSET_THIS) && (PY_VERSION_HEX >= 0x02030000))
1904     if (PyInstance_Check(pyobj)) {
1905       obj = _PyInstance_Lookup(pyobj, SWIG_This());
1906     } else {
1907       PyObject **dictptr = _PyObject_GetDictPtr(pyobj);
1908       if (dictptr != NULL) {
1909         PyObject *dict = *dictptr;
1910         obj = dict ? PyDict_GetItem(dict, SWIG_This()) : 0;
1911       } else {
1912 #ifdef PyWeakref_CheckProxy
1913         if (PyWeakref_CheckProxy(pyobj)) {
1914           PyObject *wobj = PyWeakref_GET_OBJECT(pyobj);
1915           return wobj ? SWIG_Python_GetSwigThis(wobj) : 0;
1916         }
1917 #endif
1918         obj = PyObject_GetAttr(pyobj,SWIG_This());
1919         if (obj) {
1920           Py_DECREF(obj);
1921         } else {
1922           if (PyErr_Occurred()) PyErr_Clear();
1923           return 0;
1924         }
1925       }
1926     }
1927 #else
1928     obj = PyObject_GetAttr(pyobj,SWIG_This());
1929     if (obj) {
1930       Py_DECREF(obj);
1931     } else {
1932       if (PyErr_Occurred()) PyErr_Clear();
1933       return 0;
1934     }
1935 #endif
1936     if (obj && !PySwigObject_Check(obj)) {
1937       /* a PyObject is called 'this', try to get the 'real this'
1938          PySwigObject from it */
1939       return SWIG_Python_GetSwigThis(obj);
1940     }
1941     return (PySwigObject *)obj;
1942   }
1943 }
1944
1945 /* Acquire a pointer value */
1946
1947 SWIGRUNTIME int
1948 SWIG_Python_AcquirePtr(PyObject *obj, int own) {
1949   if (own == SWIG_POINTER_OWN) {
1950     PySwigObject *sobj = SWIG_Python_GetSwigThis(obj);
1951     if (sobj) {
1952       int oldown = sobj->own;
1953       sobj->own = own;
1954       return oldown;
1955     }
1956   }
1957   return 0;
1958 }
1959
1960 /* Convert a pointer value */
1961
1962 SWIGRUNTIME int
1963 SWIG_Python_ConvertPtrAndOwn(PyObject *obj, void **ptr, swig_type_info *ty, int flags, int *own) {
1964   if (!obj) return SWIG_ERROR;
1965   if (obj == Py_None) {
1966     if (ptr) *ptr = 0;
1967     return SWIG_OK;
1968   } else {
1969     PySwigObject *sobj = SWIG_Python_GetSwigThis(obj);
1970     if (own)
1971       *own = 0;
1972     while (sobj) {
1973       void *vptr = sobj->ptr;
1974       if (ty) {
1975         swig_type_info *to = sobj->ty;
1976         if (to == ty) {
1977           /* no type cast needed */
1978           if (ptr) *ptr = vptr;
1979           break;
1980         } else {
1981           swig_cast_info *tc = SWIG_TypeCheck(to->name,ty);
1982           if (!tc) {
1983             sobj = (PySwigObject *)sobj->next;
1984           } else {
1985             if (ptr) {
1986               int newmemory = 0;
1987               *ptr = SWIG_TypeCast(tc,vptr,&newmemory);
1988               if (newmemory == SWIG_CAST_NEW_MEMORY) {
1989                 assert(own);
1990                 if (own)
1991                   *own = *own | SWIG_CAST_NEW_MEMORY;
1992               }
1993             }
1994             break;
1995           }
1996         }
1997       } else {
1998         if (ptr) *ptr = vptr;
1999         break;
2000       }
2001     }
2002     if (sobj) {
2003       if (own)
2004         *own = *own | sobj->own;
2005       if (flags & SWIG_POINTER_DISOWN) {
2006         sobj->own = 0;
2007       }
2008       return SWIG_OK;
2009     } else {
2010       int res = SWIG_ERROR;
2011       if (flags & SWIG_POINTER_IMPLICIT_CONV) {
2012         PySwigClientData *data = ty ? (PySwigClientData *) ty->clientdata : 0;
2013         if (data && !data->implicitconv) {
2014           PyObject *klass = data->klass;
2015           if (klass) {
2016             PyObject *impconv;
2017             data->implicitconv = 1; /* avoid recursion and call 'explicit' constructors*/
2018             impconv = SWIG_Python_CallFunctor(klass, obj);
2019             data->implicitconv = 0;
2020             if (PyErr_Occurred()) {
2021               PyErr_Clear();
2022               impconv = 0;
2023             }
2024             if (impconv) {
2025               PySwigObject *iobj = SWIG_Python_GetSwigThis(impconv);
2026               if (iobj) {
2027                 void *vptr;
2028                 res = SWIG_Python_ConvertPtrAndOwn((PyObject*)iobj, &vptr, ty, 0, 0);
2029                 if (SWIG_IsOK(res)) {
2030                   if (ptr) {
2031                     *ptr = vptr;
2032                     /* transfer the ownership to 'ptr' */
2033                     iobj->own = 0;
2034                     res = SWIG_AddCast(res);
2035                     res = SWIG_AddNewMask(res);
2036                   } else {
2037                     res = SWIG_AddCast(res);
2038                   }
2039                 }
2040               }
2041               Py_DECREF(impconv);
2042             }
2043           }
2044         }
2045       }
2046       return res;
2047     }
2048   }
2049 }
2050
2051 /* Convert a function ptr value */
2052
2053 SWIGRUNTIME int
2054 SWIG_Python_ConvertFunctionPtr(PyObject *obj, void **ptr, swig_type_info *ty) {
2055   if (!PyCFunction_Check(obj)) {
2056     return SWIG_ConvertPtr(obj, ptr, ty, 0);
2057   } else {
2058     void *vptr = 0;
2059
2060     /* here we get the method pointer for callbacks */
2061     const char *doc = (((PyCFunctionObject *)obj) -> m_ml -> ml_doc);
2062     const char *desc = doc ? strstr(doc, "swig_ptr: ") : 0;
2063     if (desc) {
2064       desc = ty ? SWIG_UnpackVoidPtr(desc + 10, &vptr, ty->name) : 0;
2065       if (!desc) return SWIG_ERROR;
2066     }
2067     if (ty) {
2068       swig_cast_info *tc = SWIG_TypeCheck(desc,ty);
2069       if (tc) {
2070         int newmemory = 0;
2071         *ptr = SWIG_TypeCast(tc,vptr,&newmemory);
2072         assert(!newmemory); /* newmemory handling not yet implemented */
2073       } else {
2074         return SWIG_ERROR;
2075       }
2076     } else {
2077       *ptr = vptr;
2078     }
2079     return SWIG_OK;
2080   }
2081 }
2082
2083 /* Convert a packed value value */
2084
2085 SWIGRUNTIME int
2086 SWIG_Python_ConvertPacked(PyObject *obj, void *ptr, size_t sz, swig_type_info *ty) {
2087   swig_type_info *to = PySwigPacked_UnpackData(obj, ptr, sz);
2088   if (!to) return SWIG_ERROR;
2089   if (ty) {
2090     if (to != ty) {
2091       /* check type cast? */
2092       swig_cast_info *tc = SWIG_TypeCheck(to->name,ty);
2093       if (!tc) return SWIG_ERROR;
2094     }
2095   }
2096   return SWIG_OK;
2097 }
2098
2099 /* -----------------------------------------------------------------------------
2100  * Create a new pointer object
2101  * ----------------------------------------------------------------------------- */
2102
2103 /*
2104   Create a new instance object, whitout calling __init__, and set the
2105   'this' attribute.
2106 */
2107
2108 SWIGRUNTIME PyObject*
2109 SWIG_Python_NewShadowInstance(PySwigClientData *data, PyObject *swig_this)
2110 {
2111 #if (PY_VERSION_HEX >= 0x02020000)
2112   PyObject *inst = 0;
2113   PyObject *newraw = data->newraw;
2114   if (newraw) {
2115     inst = PyObject_Call(newraw, data->newargs, NULL);
2116     if (inst) {
2117 #if !defined(SWIG_PYTHON_SLOW_GETSET_THIS)
2118       PyObject **dictptr = _PyObject_GetDictPtr(inst);
2119       if (dictptr != NULL) {
2120         PyObject *dict = *dictptr;
2121         if (dict == NULL) {
2122           dict = PyDict_New();
2123           *dictptr = dict;
2124           PyDict_SetItem(dict, SWIG_This(), swig_this);
2125         }
2126       }
2127 #else
2128       PyObject *key = SWIG_This();
2129       PyObject_SetAttr(inst, key, swig_this);
2130 #endif
2131     }
2132   } else {
2133     PyObject *dict = PyDict_New();
2134     PyDict_SetItem(dict, SWIG_This(), swig_this);
2135     inst = PyInstance_NewRaw(data->newargs, dict);
2136     Py_DECREF(dict);
2137   }
2138   return inst;
2139 #else
2140 #if (PY_VERSION_HEX >= 0x02010000)
2141   PyObject *inst;
2142   PyObject *dict = PyDict_New();
2143   PyDict_SetItem(dict, SWIG_This(), swig_this);
2144   inst = PyInstance_NewRaw(data->newargs, dict);
2145   Py_DECREF(dict);
2146   return (PyObject *) inst;
2147 #else
2148   PyInstanceObject *inst = PyObject_NEW(PyInstanceObject, &PyInstance_Type);
2149   if (inst == NULL) {
2150     return NULL;
2151   }
2152   inst->in_class = (PyClassObject *)data->newargs;
2153   Py_INCREF(inst->in_class);
2154   inst->in_dict = PyDict_New();
2155   if (inst->in_dict == NULL) {
2156     Py_DECREF(inst);
2157     return NULL;
2158   }
2159 #ifdef Py_TPFLAGS_HAVE_WEAKREFS
2160   inst->in_weakreflist = NULL;
2161 #endif
2162 #ifdef Py_TPFLAGS_GC
2163   PyObject_GC_Init(inst);
2164 #endif
2165   PyDict_SetItem(inst->in_dict, SWIG_This(), swig_this);
2166   return (PyObject *) inst;
2167 #endif
2168 #endif
2169 }
2170
2171 SWIGRUNTIME void
2172 SWIG_Python_SetSwigThis(PyObject *inst, PyObject *swig_this)
2173 {
2174  PyObject *dict;
2175 #if (PY_VERSION_HEX >= 0x02020000) && !defined(SWIG_PYTHON_SLOW_GETSET_THIS)
2176  PyObject **dictptr = _PyObject_GetDictPtr(inst);
2177  if (dictptr != NULL) {
2178    dict = *dictptr;
2179    if (dict == NULL) {
2180      dict = PyDict_New();
2181      *dictptr = dict;
2182    }
2183    PyDict_SetItem(dict, SWIG_This(), swig_this);
2184    return;
2185  }
2186 #endif
2187  dict = PyObject_GetAttrString(inst, (char*)"__dict__");
2188  PyDict_SetItem(dict, SWIG_This(), swig_this);
2189  Py_DECREF(dict);
2190 }
2191
2192
2193 SWIGINTERN PyObject *
2194 SWIG_Python_InitShadowInstance(PyObject *args) {
2195   PyObject *obj[2];
2196   if (!SWIG_Python_UnpackTuple(args,(char*)"swiginit", 2, 2, obj)) {
2197     return NULL;
2198   } else {
2199     PySwigObject *sthis = SWIG_Python_GetSwigThis(obj[0]);
2200     if (sthis) {
2201       PySwigObject_append((PyObject*) sthis, obj[1]);
2202     } else {
2203       SWIG_Python_SetSwigThis(obj[0], obj[1]);
2204     }
2205     return SWIG_Py_Void();
2206   }
2207 }
2208
2209 /* Create a new pointer object */
2210
2211 SWIGRUNTIME PyObject *
2212 SWIG_Python_NewPointerObj(void *ptr, swig_type_info *type, int flags) {
2213   if (!ptr) {
2214     return SWIG_Py_Void();
2215   } else {
2216     int own = (flags & SWIG_POINTER_OWN) ? SWIG_POINTER_OWN : 0;
2217     PyObject *robj = PySwigObject_New(ptr, type, own);
2218     PySwigClientData *clientdata = type ? (PySwigClientData *)(type->clientdata) : 0;
2219     if (clientdata && !(flags & SWIG_POINTER_NOSHADOW)) {
2220       PyObject *inst = SWIG_Python_NewShadowInstance(clientdata, robj);
2221       if (inst) {
2222         Py_DECREF(robj);
2223         robj = inst;
2224       }
2225     }
2226     return robj;
2227   }
2228 }
2229
2230 /* Create a new packed object */
2231
2232 SWIGRUNTIMEINLINE PyObject *
2233 SWIG_Python_NewPackedObj(void *ptr, size_t sz, swig_type_info *type) {
2234   return ptr ? PySwigPacked_New((void *) ptr, sz, type) : SWIG_Py_Void();
2235 }
2236
2237 /* -----------------------------------------------------------------------------*
2238  *  Get type list
2239  * -----------------------------------------------------------------------------*/
2240
2241 #ifdef SWIG_LINK_RUNTIME
2242 void *SWIG_ReturnGlobalTypeList(void *);
2243 #endif
2244
2245 SWIGRUNTIME swig_module_info *
2246 SWIG_Python_GetModule(void) {
2247   static void *type_pointer = (void *)0;
2248   /* first check if module already created */
2249   if (!type_pointer) {
2250 #ifdef SWIG_LINK_RUNTIME
2251     type_pointer = SWIG_ReturnGlobalTypeList((void *)0);
2252 #else
2253     type_pointer = PyCObject_Import((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
2254                                     (char*)"type_pointer" SWIG_TYPE_TABLE_NAME);
2255     if (PyErr_Occurred()) {
2256       PyErr_Clear();
2257       type_pointer = (void *)0;
2258     }
2259 #endif
2260   }
2261   return (swig_module_info *) type_pointer;
2262 }
2263
2264 #if PY_MAJOR_VERSION < 2
2265 /* PyModule_AddObject function was introduced in Python 2.0.  The following function
2266    is copied out of Python/modsupport.c in python version 2.3.4 */
2267 SWIGINTERN int
2268 PyModule_AddObject(PyObject *m, char *name, PyObject *o)
2269 {
2270   PyObject *dict;
2271   if (!PyModule_Check(m)) {
2272     PyErr_SetString(PyExc_TypeError,
2273                     "PyModule_AddObject() needs module as first arg");
2274     return SWIG_ERROR;
2275   }
2276   if (!o) {
2277     PyErr_SetString(PyExc_TypeError,
2278                     "PyModule_AddObject() needs non-NULL value");
2279     return SWIG_ERROR;
2280   }
2281
2282   dict = PyModule_GetDict(m);
2283   if (dict == NULL) {
2284     /* Internal error -- modules must have a dict! */
2285     PyErr_Format(PyExc_SystemError, "module '%s' has no __dict__",
2286                  PyModule_GetName(m));
2287     return SWIG_ERROR;
2288   }
2289   if (PyDict_SetItemString(dict, name, o))
2290     return SWIG_ERROR;
2291   Py_DECREF(o);
2292   return SWIG_OK;
2293 }
2294 #endif
2295
2296 SWIGRUNTIME void
2297 SWIG_Python_DestroyModule(void *vptr)
2298 {
2299   swig_module_info *swig_module = (swig_module_info *) vptr;
2300   swig_type_info **types = swig_module->types;
2301   size_t i;
2302   for (i =0; i < swig_module->size; ++i) {
2303     swig_type_info *ty = types[i];
2304     if (ty->owndata) {
2305       PySwigClientData *data = (PySwigClientData *) ty->clientdata;
2306       if (data) PySwigClientData_Del(data);
2307     }
2308   }
2309   Py_DECREF(SWIG_This());
2310 }
2311
2312 SWIGRUNTIME void
2313 SWIG_Python_SetModule(swig_module_info *swig_module) {
2314   static PyMethodDef swig_empty_runtime_method_table[] = { {NULL, NULL, 0, NULL} };/* Sentinel */
2315
2316   PyObject *module = Py_InitModule((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
2317                                    swig_empty_runtime_method_table);
2318   PyObject *pointer = PyCObject_FromVoidPtr((void *) swig_module, SWIG_Python_DestroyModule);
2319   if (pointer && module) {
2320     PyModule_AddObject(module, (char*)"type_pointer" SWIG_TYPE_TABLE_NAME, pointer);
2321   } else {
2322     Py_XDECREF(pointer);
2323   }
2324 }
2325
2326 /* The python cached type query */
2327 SWIGRUNTIME PyObject *
2328 SWIG_Python_TypeCache(void) {
2329   static PyObject *SWIG_STATIC_POINTER(cache) = PyDict_New();
2330   return cache;
2331 }
2332
2333 SWIGRUNTIME swig_type_info *
2334 SWIG_Python_TypeQuery(const char *type)
2335 {
2336   PyObject *cache = SWIG_Python_TypeCache();
2337   PyObject *key = PyString_FromString(type);
2338   PyObject *obj = PyDict_GetItem(cache, key);
2339   swig_type_info *descriptor;
2340   if (obj) {
2341     descriptor = (swig_type_info *) PyCObject_AsVoidPtr(obj);
2342   } else {
2343     swig_module_info *swig_module = SWIG_Python_GetModule();
2344     descriptor = SWIG_TypeQueryModule(swig_module, swig_module, type);
2345     if (descriptor) {
2346       obj = PyCObject_FromVoidPtr(descriptor, NULL);
2347       PyDict_SetItem(cache, key, obj);
2348       Py_DECREF(obj);
2349     }
2350   }
2351   Py_DECREF(key);
2352   return descriptor;
2353 }
2354
2355 /*
2356    For backward compatibility only
2357 */
2358 #define SWIG_POINTER_EXCEPTION  0
2359 #define SWIG_arg_fail(arg)      SWIG_Python_ArgFail(arg)
2360 #define SWIG_MustGetPtr(p, type, argnum, flags)  SWIG_Python_MustGetPtr(p, type, argnum, flags)
2361
2362 SWIGRUNTIME int
2363 SWIG_Python_AddErrMesg(const char* mesg, int infront)
2364 {
2365   if (PyErr_Occurred()) {
2366     PyObject *type = 0;
2367     PyObject *value = 0;
2368     PyObject *traceback = 0;
2369     PyErr_Fetch(&type, &value, &traceback);
2370     if (value) {
2371       PyObject *old_str = PyObject_Str(value);
2372       Py_XINCREF(type);
2373       PyErr_Clear();
2374       if (infront) {
2375         PyErr_Format(type, "%s %s", mesg, PyString_AsString(old_str));
2376       } else {
2377         PyErr_Format(type, "%s %s", PyString_AsString(old_str), mesg);
2378       }
2379       Py_DECREF(old_str);
2380     }
2381     return 1;
2382   } else {
2383     return 0;
2384   }
2385 }
2386
2387 SWIGRUNTIME int
2388 SWIG_Python_ArgFail(int argnum)
2389 {
2390   if (PyErr_Occurred()) {
2391     /* add information about failing argument */
2392     char mesg[256];
2393     PyOS_snprintf(mesg, sizeof(mesg), "argument number %d:", argnum);
2394     return SWIG_Python_AddErrMesg(mesg, 1);
2395   } else {
2396     return 0;
2397   }
2398 }
2399
2400 SWIGRUNTIMEINLINE const char *
2401 PySwigObject_GetDesc(PyObject *self)
2402 {
2403   PySwigObject *v = (PySwigObject *)self;
2404   swig_type_info *ty = v ? v->ty : 0;
2405   return ty ? ty->str : (char*)"";
2406 }
2407
2408 SWIGRUNTIME void
2409 SWIG_Python_TypeError(const char *type, PyObject *obj)
2410 {
2411   if (type) {
2412 #if defined(SWIG_COBJECT_TYPES)
2413     if (obj && PySwigObject_Check(obj)) {
2414       const char *otype = (const char *) PySwigObject_GetDesc(obj);
2415       if (otype) {
2416         PyErr_Format(PyExc_TypeError, "a '%s' is expected, 'PySwigObject(%s)' is received",
2417                      type, otype);
2418         return;
2419       }
2420     } else
2421 #endif
2422     {
2423       const char *otype = (obj ? obj->ob_type->tp_name : 0);
2424       if (otype) {
2425         PyObject *str = PyObject_Str(obj);
2426         const char *cstr = str ? PyString_AsString(str) : 0;
2427         if (cstr) {
2428           PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s(%s)' is received",
2429                        type, otype, cstr);
2430         } else {
2431           PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s' is received",
2432                        type, otype);
2433         }
2434         Py_XDECREF(str);
2435         return;
2436       }
2437     }
2438     PyErr_Format(PyExc_TypeError, "a '%s' is expected", type);
2439   } else {
2440     PyErr_Format(PyExc_TypeError, "unexpected type is received");
2441   }
2442 }
2443
2444
2445 /* Convert a pointer value, signal an exception on a type mismatch */
2446 SWIGRUNTIME void *
2447 SWIG_Python_MustGetPtr(PyObject *obj, swig_type_info *ty, int argnum, int flags) {
2448   void *result;
2449   if (SWIG_Python_ConvertPtr(obj, &result, ty, flags) == -1) {
2450     PyErr_Clear();
2451     if (flags & SWIG_POINTER_EXCEPTION) {
2452       SWIG_Python_TypeError(SWIG_TypePrettyName(ty), obj);
2453       SWIG_Python_ArgFail(argnum);
2454     }
2455   }
2456   return result;
2457 }
2458
2459
2460 #ifdef __cplusplus
2461 #if 0
2462 { /* cc-mode */
2463 #endif
2464 }
2465 #endif
2466
2467
2468
2469 #define SWIG_exception_fail(code, msg) do { SWIG_Error(code, msg); SWIG_fail; } while(0)
2470
2471 #define SWIG_contract_assert(expr, msg) if (!(expr)) { SWIG_Error(SWIG_RuntimeError, msg); SWIG_fail; } else
2472
2473
2474
2475   #define SWIG_exception(code, msg) do { SWIG_Error(code, msg); SWIG_fail;; } while(0)
2476
2477
2478 /* -------- TYPES TABLE (BEGIN) -------- */
2479
2480 #define SWIGTYPE_p_TALLOC_CTX swig_types[0]
2481 #define SWIGTYPE_p_char swig_types[1]
2482 #define SWIGTYPE_p_f_p_void_enum_ldb_debug_level_p_q_const__char_va_list__void swig_types[2]
2483 #define SWIGTYPE_p_int swig_types[3]
2484 #define SWIGTYPE_p_ldb_context swig_types[4]
2485 #define SWIGTYPE_p_ldb_dn swig_types[5]
2486 #define SWIGTYPE_p_ldb_ldif swig_types[6]
2487 #define SWIGTYPE_p_ldb_message swig_types[7]
2488 #define SWIGTYPE_p_ldb_message_element swig_types[8]
2489 #define SWIGTYPE_p_ldb_module_ops swig_types[9]
2490 #define SWIGTYPE_p_ldb_result swig_types[10]
2491 #define SWIGTYPE_p_ldb_val swig_types[11]
2492 #define SWIGTYPE_p_long_long swig_types[12]
2493 #define SWIGTYPE_p_p_char swig_types[13]
2494 #define SWIGTYPE_p_p_ldb_control swig_types[14]
2495 #define SWIGTYPE_p_p_ldb_result swig_types[15]
2496 #define SWIGTYPE_p_short swig_types[16]
2497 #define SWIGTYPE_p_signed_char swig_types[17]
2498 #define SWIGTYPE_p_unsigned_char swig_types[18]
2499 #define SWIGTYPE_p_unsigned_int swig_types[19]
2500 #define SWIGTYPE_p_unsigned_long swig_types[20]
2501 #define SWIGTYPE_p_unsigned_long_long swig_types[21]
2502 #define SWIGTYPE_p_unsigned_short swig_types[22]
2503 #define SWIGTYPE_p_void swig_types[23]
2504 static swig_type_info *swig_types[25];
2505 static swig_module_info swig_module = {swig_types, 24, 0, 0, 0, 0};
2506 #define SWIG_TypeQuery(name) SWIG_TypeQueryModule(&swig_module, &swig_module, name)
2507 #define SWIG_MangledTypeQuery(name) SWIG_MangledTypeQueryModule(&swig_module, &swig_module, name)
2508
2509 /* -------- TYPES TABLE (END) -------- */
2510
2511 #if (PY_VERSION_HEX <= 0x02000000)
2512 # if !defined(SWIG_PYTHON_CLASSIC)
2513 #  error "This python version requires swig to be run with the '-classic' option"
2514 # endif
2515 #endif
2516 #if (PY_VERSION_HEX <= 0x02020000)
2517 # error "This python version requires swig to be run with the '-nomodern' option"
2518 #endif
2519 #if (PY_VERSION_HEX <= 0x02020000)
2520 # error "This python version requires swig to be run with the '-nomodernargs' option"
2521 #endif
2522 #ifndef METH_O
2523 # error "This python version requires swig to be run with the '-nofastunpack' option"
2524 #endif
2525 #ifdef SWIG_TypeQuery
2526 # undef SWIG_TypeQuery
2527 #endif
2528 #define SWIG_TypeQuery SWIG_Python_TypeQuery
2529
2530 /*-----------------------------------------------
2531               @(target):= _ldb.so
2532   ------------------------------------------------*/
2533 #define SWIG_init    init_ldb
2534
2535 #define SWIG_name    "_ldb"
2536
2537 #define SWIGVERSION 0x010335
2538 #define SWIG_VERSION SWIGVERSION
2539
2540
2541 #define SWIG_as_voidptr(a) (void *)((const void *)(a))
2542 #define SWIG_as_voidptrptr(a) ((void)SWIG_as_voidptr(*a),(void**)(a))
2543
2544
2545
2546 #include <stdint.h>
2547 #include <stdbool.h>
2548 #include "talloc.h"
2549 #include "ldb.h"
2550 #include "ldb_errors.h"
2551 #include "ldb_private.h"
2552
2553 typedef struct ldb_message ldb_msg;
2554 typedef struct ldb_context ldb;
2555 typedef struct ldb_dn ldb_dn;
2556 typedef struct ldb_ldif ldb_ldif;
2557 typedef struct ldb_message_element ldb_message_element;
2558 typedef int ldb_error;
2559 typedef int ldb_int_error;
2560
2561
2562
2563   #define SWIG_From_long   PyInt_FromLong
2564
2565
2566 SWIGINTERNINLINE PyObject *
2567 SWIG_From_int  (int value)
2568 {
2569   return SWIG_From_long  (value);
2570 }
2571
2572
2573 PyObject *ldb_val_to_py_object(struct ldb_context *ldb_ctx,
2574                                struct ldb_message_element *el,
2575                                struct ldb_val *val)
2576 {
2577         const struct ldb_schema_attribute *a;
2578         struct ldb_val new_val;
2579         TALLOC_CTX *mem_ctx = talloc_new(NULL);
2580         PyObject *ret;
2581
2582         new_val = *val;
2583
2584         if (ldb_ctx != NULL) {
2585                 a = ldb_schema_attribute_by_name(ldb_ctx, el->name);
2586
2587                 if (a != NULL) {
2588                         if (a->syntax->ldif_write_fn(ldb_ctx, mem_ctx, val, &new_val) != 0) {
2589                                 talloc_free(mem_ctx);
2590                                 return NULL;
2591                         }
2592                 }
2593         }
2594
2595         ret = PyString_FromStringAndSize((const char *)new_val.data, new_val.length);
2596
2597         talloc_free(mem_ctx);
2598
2599         return ret;
2600 }
2601
2602
2603
2604 SWIGINTERN swig_type_info*
2605 SWIG_pchar_descriptor(void)
2606 {
2607   static int init = 0;
2608   static swig_type_info* info = 0;
2609   if (!init) {
2610     info = SWIG_TypeQuery("_p_char");
2611     init = 1;
2612   }
2613   return info;
2614 }
2615
2616
2617 SWIGINTERN int
2618 SWIG_AsCharPtrAndSize(PyObject *obj, char** cptr, size_t* psize, int *alloc)
2619 {
2620   if (PyString_Check(obj)) {
2621     char *cstr; Py_ssize_t len;
2622     PyString_AsStringAndSize(obj, &cstr, &len);
2623     if (cptr)  {
2624       if (alloc) {
2625         /*
2626            In python the user should not be able to modify the inner
2627            string representation. To warranty that, if you define
2628            SWIG_PYTHON_SAFE_CSTRINGS, a new/copy of the python string
2629            buffer is always returned.
2630
2631            The default behavior is just to return the pointer value,
2632            so, be careful.
2633         */
2634 #if defined(SWIG_PYTHON_SAFE_CSTRINGS)
2635         if (*alloc != SWIG_OLDOBJ)
2636 #else
2637         if (*alloc == SWIG_NEWOBJ)
2638 #endif
2639           {
2640             *cptr = (char *)memcpy((char *)malloc((len + 1)*sizeof(char)), cstr, sizeof(char)*(len + 1));
2641             *alloc = SWIG_NEWOBJ;
2642           }
2643         else {
2644           *cptr = cstr;
2645           *alloc = SWIG_OLDOBJ;
2646         }
2647       } else {
2648         *cptr = PyString_AsString(obj);
2649       }
2650     }
2651     if (psize) *psize = len + 1;
2652     return SWIG_OK;
2653   } else {
2654     swig_type_info* pchar_descriptor = SWIG_pchar_descriptor();
2655     if (pchar_descriptor) {
2656       void* vptr = 0;
2657       if (SWIG_ConvertPtr(obj, &vptr, pchar_descriptor, 0) == SWIG_OK) {
2658         if (cptr) *cptr = (char *) vptr;
2659         if (psize) *psize = vptr ? (strlen((char *)vptr) + 1) : 0;
2660         if (alloc) *alloc = SWIG_OLDOBJ;
2661         return SWIG_OK;
2662       }
2663     }
2664   }
2665   return SWIG_TypeError;
2666 }
2667
2668
2669
2670
2671 SWIGINTERN ldb_dn *new_ldb_dn(ldb *ldb_ctx,char const *str){
2672             ldb_dn *ret = ldb_dn_new(ldb_ctx, ldb_ctx, str);
2673             /* ldb_dn_new() doesn't accept NULL as memory context, so
2674                we do it this way... */
2675             talloc_steal(NULL, ret);
2676
2677             if (ret == NULL)
2678                 SWIG_exception(SWIG_ValueError,
2679                                 "unable to parse dn string");
2680 fail:
2681             return ret;
2682         }
2683 SWIGINTERN void delete_ldb_dn(ldb_dn *self){ talloc_free(self); }
2684
2685 SWIGINTERNINLINE PyObject*
2686   SWIG_From_bool  (bool value)
2687 {
2688   return PyBool_FromLong(value ? 1 : 0);
2689 }
2690
2691
2692 SWIGINTERNINLINE PyObject *
2693 SWIG_FromCharPtrAndSize(const char* carray, size_t size)
2694 {
2695   if (carray) {
2696     if (size > INT_MAX) {
2697       swig_type_info* pchar_descriptor = SWIG_pchar_descriptor();
2698       return pchar_descriptor ?
2699         SWIG_NewPointerObj((char *)(carray), pchar_descriptor, 0) : SWIG_Py_Void();
2700     } else {
2701       return PyString_FromStringAndSize(carray, (int)(size));
2702     }
2703   } else {
2704     return SWIG_Py_Void();
2705   }
2706 }
2707
2708
2709 SWIGINTERNINLINE PyObject *
2710 SWIG_FromCharPtr(const char *cptr)
2711 {
2712   return SWIG_FromCharPtrAndSize(cptr, (cptr ? strlen(cptr) : 0));
2713 }
2714
2715 SWIGINTERN ldb_dn *ldb_dn_parent(ldb_dn *self){ return ldb_dn_get_parent(NULL, self); }
2716 SWIGINTERN char const *ldb_dn_canonical_str(ldb_dn *self){
2717             return ldb_dn_canonical_string(self, self);
2718         }
2719 SWIGINTERN char const *ldb_dn_canonical_ex_str(ldb_dn *self){
2720             return ldb_dn_canonical_ex_string(self, self);
2721         }
2722 SWIGINTERN char *ldb_dn___repr__(ldb_dn *self){
2723             char *dn = ldb_dn_get_linearized(self), *ret;
2724             asprintf(&ret, "Dn('%s')", dn);
2725             talloc_free(dn);
2726             return ret;
2727         }
2728 SWIGINTERN ldb_dn *ldb_dn___add__(ldb_dn *self,ldb_dn *other){
2729             ldb_dn *ret = ldb_dn_copy(NULL, self);
2730             ldb_dn_add_child(ret, other);
2731             return ret;
2732         }
2733
2734 struct ldb_context *ldb_context_from_py_object(PyObject *py_obj)
2735 {
2736         struct ldb_context *ldb_ctx;
2737     if (SWIG_ConvertPtr(py_obj, (void *)&ldb_ctx, SWIGTYPE_p_ldb_context, 0 |  0 ) < 0)
2738         return NULL;
2739     return ldb_ctx;
2740 }
2741
2742 int ldb_dn_from_pyobject(TALLOC_CTX *mem_ctx, PyObject *object,
2743                          struct ldb_context *ldb_ctx, ldb_dn **dn)
2744 {
2745     int ret;
2746     struct ldb_dn *odn;
2747     if (ldb_ctx != NULL && PyString_Check(object)) {
2748         odn = ldb_dn_new(mem_ctx, ldb_ctx, PyString_AsString(object));
2749         if (!odn) {
2750                 return SWIG_ERROR;
2751         }
2752         *dn = odn;
2753         return 0;
2754     }
2755     ret = SWIG_ConvertPtr(object, (void **)&odn, SWIGTYPE_p_ldb_dn,
2756                            SWIG_POINTER_EXCEPTION);
2757     *dn = ldb_dn_copy(mem_ctx, odn);
2758     if (odn && !*dn) {
2759         return SWIG_ERROR;
2760     }
2761     return ret;
2762 }
2763
2764 ldb_message_element *ldb_msg_element_from_pyobject(TALLOC_CTX *mem_ctx,
2765                                                PyObject *set_obj, int flags,
2766                                                const char *attr_name)
2767 {
2768     struct ldb_message_element *me = talloc(mem_ctx, struct ldb_message_element);
2769     me->name = attr_name;
2770     me->flags = flags;
2771     if (PyString_Check(set_obj)) {
2772         me->num_values = 1;
2773         me->values = talloc_array(me, struct ldb_val, me->num_values);
2774         me->values[0].length = PyString_Size(set_obj);
2775         me->values[0].data = (uint8_t *)talloc_strdup(me->values,
2776                                            PyString_AsString(set_obj));
2777     } else if (PySequence_Check(set_obj)) {
2778         int i;
2779         me->num_values = PySequence_Size(set_obj);
2780         me->values = talloc_array(me, struct ldb_val, me->num_values);
2781         for (i = 0; i < me->num_values; i++) {
2782             PyObject *obj = PySequence_GetItem(set_obj, i);
2783             me->values[i].length = PyString_Size(obj);
2784             me->values[i].data = (uint8_t *)PyString_AsString(obj);
2785         }
2786     } else {
2787         talloc_free(me);
2788         me = NULL;
2789     }
2790
2791     return me;
2792 }
2793
2794 PyObject *ldb_msg_element_to_set(struct ldb_context *ldb_ctx,
2795                                  ldb_message_element *me)
2796 {
2797     int i;
2798     PyObject *result;
2799
2800     /* Python << 2.5 doesn't have PySet_New and PySet_Add. */
2801     result = PyList_New(me->num_values);
2802
2803     for (i = 0; i < me->num_values; i++) {
2804         PyList_SetItem(result, i,
2805             ldb_val_to_py_object(ldb_ctx, me, &me->values[i]));
2806     }
2807
2808     return result;
2809 }
2810
2811
2812 SWIGINTERN int ldb_message_element___cmp__(ldb_message_element *self,ldb_message_element *other){
2813             return ldb_msg_element_compare(self, other);
2814         }
2815 SWIGINTERN PyObject *ldb_message_element___iter__(ldb_message_element *self){
2816             return PyObject_GetIter(ldb_msg_element_to_set(NULL, self));
2817         }
2818 SWIGINTERN PyObject *ldb_message_element___set__(ldb_message_element *self){
2819             return ldb_msg_element_to_set(NULL, self);
2820         }
2821
2822 #include <limits.h>
2823 #if !defined(SWIG_NO_LLONG_MAX)
2824 # if !defined(LLONG_MAX) && defined(__GNUC__) && defined (__LONG_LONG_MAX__)
2825 #   define LLONG_MAX __LONG_LONG_MAX__
2826 #   define LLONG_MIN (-LLONG_MAX - 1LL)
2827 #   define ULLONG_MAX (LLONG_MAX * 2ULL + 1ULL)
2828 # endif
2829 #endif
2830
2831
2832 SWIGINTERN int
2833 SWIG_AsVal_double (PyObject *obj, double *val)
2834 {
2835   int res = SWIG_TypeError;
2836   if (PyFloat_Check(obj)) {
2837     if (val) *val = PyFloat_AsDouble(obj);
2838     return SWIG_OK;
2839   } else if (PyInt_Check(obj)) {
2840     if (val) *val = PyInt_AsLong(obj);
2841     return SWIG_OK;
2842   } else if (PyLong_Check(obj)) {
2843     double v = PyLong_AsDouble(obj);
2844     if (!PyErr_Occurred()) {
2845       if (val) *val = v;
2846       return SWIG_OK;
2847     } else {
2848       PyErr_Clear();
2849     }
2850   }
2851 #ifdef SWIG_PYTHON_CAST_MODE
2852   {
2853     int dispatch = 0;
2854     double d = PyFloat_AsDouble(obj);
2855     if (!PyErr_Occurred()) {
2856       if (val) *val = d;
2857       return SWIG_AddCast(SWIG_OK);
2858     } else {
2859       PyErr_Clear();
2860     }
2861     if (!dispatch) {
2862       long v = PyLong_AsLong(obj);
2863       if (!PyErr_Occurred()) {
2864         if (val) *val = v;
2865         return SWIG_AddCast(SWIG_AddCast(SWIG_OK));
2866       } else {
2867         PyErr_Clear();
2868       }
2869     }
2870   }
2871 #endif
2872   return res;
2873 }
2874
2875
2876 #include <float.h>
2877
2878
2879 #include <math.h>
2880
2881
2882 SWIGINTERNINLINE int
2883 SWIG_CanCastAsInteger(double *d, double min, double max) {
2884   double x = *d;
2885   if ((min <= x && x <= max)) {
2886    double fx = floor(x);
2887    double cx = ceil(x);
2888    double rd =  ((x - fx) < 0.5) ? fx : cx; /* simple rint */
2889    if ((errno == EDOM) || (errno == ERANGE)) {
2890      errno = 0;
2891    } else {
2892      double summ, reps, diff;
2893      if (rd < x) {
2894        diff = x - rd;
2895      } else if (rd > x) {
2896        diff = rd - x;
2897      } else {
2898        return 1;
2899      }
2900      summ = rd + x;
2901      reps = diff/summ;
2902      if (reps < 8*DBL_EPSILON) {
2903        *d = rd;
2904        return 1;
2905      }
2906    }
2907   }
2908   return 0;
2909 }
2910
2911
2912 SWIGINTERN int
2913 SWIG_AsVal_long (PyObject *obj, long* val)
2914 {
2915   if (PyInt_Check(obj)) {
2916     if (val) *val = PyInt_AsLong(obj);
2917     return SWIG_OK;
2918   } else if (PyLong_Check(obj)) {
2919     long v = PyLong_AsLong(obj);
2920     if (!PyErr_Occurred()) {
2921       if (val) *val = v;
2922       return SWIG_OK;
2923     } else {
2924       PyErr_Clear();
2925     }
2926   }
2927 #ifdef SWIG_PYTHON_CAST_MODE
2928   {
2929     int dispatch = 0;
2930     long v = PyInt_AsLong(obj);
2931     if (!PyErr_Occurred()) {
2932       if (val) *val = v;
2933       return SWIG_AddCast(SWIG_OK);
2934     } else {
2935       PyErr_Clear();
2936     }
2937     if (!dispatch) {
2938       double d;
2939       int res = SWIG_AddCast(SWIG_AsVal_double (obj,&d));
2940       if (SWIG_IsOK(res) && SWIG_CanCastAsInteger(&d, LONG_MIN, LONG_MAX)) {
2941         if (val) *val = (long)(d);
2942         return res;
2943       }
2944     }
2945   }
2946 #endif
2947   return SWIG_TypeError;
2948 }
2949
2950
2951 SWIGINTERN int
2952 SWIG_AsVal_int (PyObject * obj, int *val)
2953 {
2954   long v;
2955   int res = SWIG_AsVal_long (obj, &v);
2956   if (SWIG_IsOK(res)) {
2957     if ((v < INT_MIN || v > INT_MAX)) {
2958       return SWIG_OverflowError;
2959     } else {
2960       if (val) *val = (int)(v);
2961     }
2962   }
2963   return res;
2964 }
2965
2966 SWIGINTERN ldb_message_element *new_ldb_message_element(PyObject *set_obj,int flags,char const *name){
2967             return ldb_msg_element_from_pyobject(NULL, set_obj, flags, name);
2968         }
2969 SWIGINTERN int ldb_message_element___len__(ldb_message_element *self){
2970             return self->num_values;
2971         }
2972 SWIGINTERN PyObject *ldb_message_element_get(ldb_message_element *self,int i){
2973             if (i < 0 || i >= self->num_values)
2974                 return Py_None;
2975
2976             return ldb_val_to_py_object(NULL, self, &self->values[i]);
2977         }
2978 SWIGINTERN void delete_ldb_message_element(ldb_message_element *self){ talloc_free(self); }
2979
2980     PyObject *ldb_msg_list_elements(ldb_msg *msg)
2981     {
2982         int i, j = 0;
2983         PyObject *obj = PyList_New(msg->num_elements+(msg->dn != NULL?1:0));
2984         if (msg->dn != NULL) {
2985             PyList_SetItem(obj, j, PyString_FromString("dn"));
2986             j++;
2987         }
2988         for (i = 0; i < msg->num_elements; i++) {
2989             PyList_SetItem(obj, j, PyString_FromString(msg->elements[i].name));
2990             j++;
2991         }
2992         return obj;
2993     }
2994
2995 SWIGINTERN ldb_msg *new_ldb_msg(ldb_dn *dn){
2996             ldb_msg *ret = ldb_msg_new(NULL);
2997             ret->dn = talloc_reference(ret, dn);
2998             return ret;
2999         }
3000 SWIGINTERN void delete_ldb_msg(ldb_msg *self){ talloc_free(self); }
3001 SWIGINTERN void ldb_msg___setitem____SWIG_0(ldb_msg *self,char const *attr_name,ldb_message_element *val){
3002             struct ldb_message_element *el;
3003
3004             ldb_msg_remove_attr(self, attr_name);
3005
3006             el = talloc(self, struct ldb_message_element);
3007             el->name = talloc_strdup(el, attr_name);
3008             el->num_values = val->num_values;
3009             el->values = talloc_reference(el, val->values);
3010
3011             ldb_msg_add(self, el, val->flags);
3012         }
3013 SWIGINTERN void ldb_msg___setitem____SWIG_1(ldb_msg *self,char const *attr_name,PyObject *val){
3014             struct ldb_message_element *el = ldb_msg_element_from_pyobject(NULL,
3015                                                 val, 0, attr_name);
3016             talloc_steal(self, el);
3017             ldb_msg_remove_attr(self, attr_name);
3018             ldb_msg_add(self, el, el->flags);
3019         }
3020 SWIGINTERN unsigned int ldb_msg___len__(ldb_msg *self){ return self->num_elements; }
3021
3022 SWIGINTERNINLINE PyObject*
3023 SWIG_From_unsigned_SS_long  (unsigned long value)
3024 {
3025   return (value > LONG_MAX) ?
3026     PyLong_FromUnsignedLong(value) : PyInt_FromLong((long)(value));
3027 }
3028
3029
3030 SWIGINTERNINLINE PyObject *
3031 SWIG_From_unsigned_SS_int  (unsigned int value)
3032 {
3033   return SWIG_From_unsigned_SS_long  (value);
3034 }
3035
3036 SWIGINTERN PyObject *ldb_msg_keys(ldb_msg *self){
3037             return ldb_msg_list_elements(self);
3038         }
3039 SWIGINTERN PyObject *ldb_msg___iter__(ldb_msg *self){
3040             return PyObject_GetIter(ldb_msg_list_elements(self));
3041         }
3042
3043 static void py_ldb_debug(void *context, enum ldb_debug_level level, const char *fmt, va_list ap) PRINTF_ATTRIBUTE(3, 0);
3044
3045 static void py_ldb_debug(void *context, enum ldb_debug_level level, const char *fmt, va_list ap)
3046 {
3047     char *text;
3048     PyObject *fn = context;
3049
3050     vasprintf(&text, fmt, ap);
3051     PyObject_CallFunction(fn, (char *)"(i,s)", level, text);
3052     free(text);
3053 }
3054
3055
3056     static PyObject *ldb_ldif_to_pyobject(ldb_ldif *ldif)
3057     {
3058         if (ldif == NULL) {
3059             return Py_None;
3060         } else {
3061             return Py_BuildValue((char *)"(iO)", ldif->changetype,
3062                    SWIG_NewPointerObj(ldif->msg, SWIGTYPE_p_ldb_message, 0));
3063         }
3064     }
3065
3066
3067 PyObject *PyExc_LdbError;
3068
3069 SWIGINTERN ldb *new_ldb(){ return ldb_init(NULL); }
3070
3071 SWIGINTERN int
3072 SWIG_AsVal_unsigned_SS_long (PyObject *obj, unsigned long *val)
3073 {
3074   if (PyInt_Check(obj)) {
3075     long v = PyInt_AsLong(obj);
3076     if (v >= 0) {
3077       if (val) *val = v;
3078       return SWIG_OK;
3079     } else {
3080       return SWIG_OverflowError;
3081     }
3082   } else if (PyLong_Check(obj)) {
3083     unsigned long v = PyLong_AsUnsignedLong(obj);
3084     if (!PyErr_Occurred()) {
3085       if (val) *val = v;
3086       return SWIG_OK;
3087     } else {
3088       PyErr_Clear();
3089     }
3090   }
3091 #ifdef SWIG_PYTHON_CAST_MODE
3092   {
3093     int dispatch = 0;
3094     unsigned long v = PyLong_AsUnsignedLong(obj);
3095     if (!PyErr_Occurred()) {
3096       if (val) *val = v;
3097       return SWIG_AddCast(SWIG_OK);
3098     } else {
3099       PyErr_Clear();
3100     }
3101     if (!dispatch) {
3102       double d;
3103       int res = SWIG_AddCast(SWIG_AsVal_double (obj,&d));
3104       if (SWIG_IsOK(res) && SWIG_CanCastAsInteger(&d, 0, ULONG_MAX)) {
3105         if (val) *val = (unsigned long)(d);
3106         return res;
3107       }
3108     }
3109   }
3110 #endif
3111   return SWIG_TypeError;
3112 }
3113
3114
3115 SWIGINTERN int
3116 SWIG_AsVal_unsigned_SS_int (PyObject * obj, unsigned int *val)
3117 {
3118   unsigned long v;
3119   int res = SWIG_AsVal_unsigned_SS_long (obj, &v);
3120   if (SWIG_IsOK(res)) {
3121     if ((v > UINT_MAX)) {
3122       return SWIG_OverflowError;
3123     } else {
3124       if (val) *val = (unsigned int)(v);
3125     }
3126   }
3127   return res;
3128 }
3129
3130 SWIGINTERN void delete_ldb(ldb *self){ talloc_free(self); }
3131 SWIGINTERN ldb_error ldb_search_ex(ldb *self,TALLOC_CTX *mem_ctx,ldb_dn *base,enum ldb_scope scope,char const *expression,char const *const *attrs,struct ldb_control **controls,struct ldb_result **OUT){
3132             int ret;
3133             struct ldb_result *res;
3134             struct ldb_request *req;
3135             res = talloc_zero(mem_ctx, struct ldb_result);
3136             if (!res) {
3137                 return 1;
3138             }
3139
3140             ret = ldb_build_search_req(&req, self, mem_ctx,
3141                            base?base:ldb_get_default_basedn(self),
3142                            scope,
3143                            expression,
3144                            attrs,
3145                            controls,
3146                            res,
3147                            ldb_search_default_callback);
3148
3149             if (ret != 0) {
3150                 talloc_free(res);
3151                 return ret;
3152             }
3153
3154             ldb_set_timeout(self, req, 0); /* use default timeout */
3155
3156             ret = ldb_request(self, req);
3157
3158             if (ret == 0) {
3159                 ret = ldb_wait(req->handle, LDB_WAIT_ALL);
3160             }
3161
3162             talloc_free(req);
3163
3164             *OUT = res;
3165             return ret;
3166         }
3167 SWIGINTERN PyObject *ldb_schema_format_value(ldb *self,char const *element_name,PyObject *val){
3168                 const struct ldb_schema_attribute *a;
3169                 struct ldb_val old_val;
3170                 struct ldb_val new_val;
3171                 TALLOC_CTX *mem_ctx = talloc_new(NULL);
3172                 PyObject *ret;
3173
3174                 old_val.data = PyString_AsString(val);
3175                 old_val.length = PyString_Size(val);
3176
3177                 a = ldb_schema_attribute_by_name(self, element_name);
3178
3179                 if (a == NULL) {
3180                         return Py_None;
3181                 }
3182
3183                 if (a->syntax->ldif_write_fn(self, mem_ctx, &old_val, &new_val) != 0) {
3184                         talloc_free(mem_ctx);
3185                         return Py_None;
3186                  }
3187
3188                 ret = PyString_FromStringAndSize((const char *)new_val.data, new_val.length);
3189
3190                 talloc_free(mem_ctx);
3191
3192                 return ret;
3193         }
3194 SWIGINTERN ldb_error ldb___contains__(ldb *self,ldb_dn *dn,struct ldb_result **result_as_bool){
3195             return ldb_search(self, dn, LDB_SCOPE_BASE, NULL, NULL,
3196                              result_as_bool);
3197         }
3198 SWIGINTERN PyObject *ldb_parse_ldif(ldb *self,char const *s){
3199             PyObject *list = PyList_New(0);
3200             struct ldb_ldif *ldif;
3201             while ((ldif = ldb_ldif_read_string(self, &s)) != NULL) {
3202                 PyList_Append(list, ldb_ldif_to_pyobject(ldif));
3203             }
3204             return PyObject_GetIter(list);
3205         }
3206 SWIGINTERN char *ldb___repr__(ldb *self){
3207             char *ret;
3208             asprintf(&ret, "<ldb connection at 0x%x>", ret);
3209             return ret;
3210         }
3211
3212 static char *timestring(time_t t)
3213 {
3214     char *tresult = ldb_timestring(NULL, t);
3215     char *result = strdup(tresult);
3216     talloc_free(tresult);
3217     return result;
3218 }
3219
3220 #ifdef __cplusplus
3221 extern "C" {
3222 #endif
3223 SWIGINTERN PyObject *_wrap_ldb_val_to_py_object(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
3224   PyObject *resultobj = 0;
3225   struct ldb_context *arg1 = (struct ldb_context *) 0 ;
3226   struct ldb_message_element *arg2 = (struct ldb_message_element *) 0 ;
3227   struct ldb_val *arg3 = (struct ldb_val *) 0 ;
3228   PyObject *result = 0 ;
3229   void *argp1 = 0 ;
3230   int res1 = 0 ;
3231   void *argp2 = 0 ;
3232   int res2 = 0 ;
3233   void *argp3 = 0 ;
3234   int res3 = 0 ;
3235   PyObject * obj0 = 0 ;
3236   PyObject * obj1 = 0 ;
3237   PyObject * obj2 = 0 ;
3238   char *  kwnames[] = {
3239     (char *) "ldb_ctx",(char *) "el",(char *) "val", NULL
3240   };
3241
3242   if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ldb_val_to_py_object",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
3243   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ldb_context, 0 |  0 );
3244   if (!SWIG_IsOK(res1)) {
3245     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ldb_val_to_py_object" "', argument " "1"" of type '" "struct ldb_context *""'");
3246   }
3247   arg1 = (struct ldb_context *)(argp1);
3248   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_ldb_message_element, 0 |  0 );
3249   if (!SWIG_IsOK(res2)) {
3250     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ldb_val_to_py_object" "', argument " "2"" of type '" "struct ldb_message_element *""'");
3251   }
3252   arg2 = (struct ldb_message_element *)(argp2);
3253   res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_ldb_val, 0 |  0 );
3254   if (!SWIG_IsOK(res3)) {
3255     SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ldb_val_to_py_object" "', argument " "3"" of type '" "struct ldb_val *""'");
3256   }
3257   arg3 = (struct ldb_val *)(argp3);
3258   if (arg1 == NULL)
3259   SWIG_exception(SWIG_ValueError,
3260     "ldb context must be non-NULL");
3261   result = (PyObject *)ldb_val_to_py_object(arg1,arg2,arg3);
3262   resultobj = result;
3263   return resultobj;
3264 fail:
3265   return NULL;
3266 }
3267
3268
3269 SWIGINTERN PyObject *_wrap_new_Dn(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
3270   PyObject *resultobj = 0;
3271   ldb *arg1 = (ldb *) 0 ;
3272   char *arg2 = (char *) 0 ;
3273   ldb_dn *result = 0 ;
3274   void *argp1 = 0 ;
3275   int res1 = 0 ;
3276   int res2 ;
3277   char *buf2 = 0 ;
3278   int alloc2 = 0 ;
3279   PyObject * obj0 = 0 ;
3280   PyObject * obj1 = 0 ;
3281   char *  kwnames[] = {
3282     (char *) "ldb_ctx",(char *) "str", NULL
3283   };
3284
3285   if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_Dn",kwnames,&obj0,&obj1)) SWIG_fail;
3286   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ldb_context, 0 |  0 );
3287   if (!SWIG_IsOK(res1)) {
3288     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Dn" "', argument " "1"" of type '" "ldb *""'");
3289   }
3290   arg1 = (ldb *)(argp1);
3291   res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
3292   if (!SWIG_IsOK(res2)) {
3293     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_Dn" "', argument " "2"" of type '" "char const *""'");
3294   }
3295   arg2 = (char *)(buf2);
3296   if (arg1 == NULL)
3297   SWIG_exception(SWIG_ValueError,
3298     "ldb context must be non-NULL");
3299   result = (ldb_dn *)new_ldb_dn(arg1,(char const *)arg2);
3300   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ldb_dn, SWIG_POINTER_NEW |  0 );
3301   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
3302   return resultobj;
3303 fail:
3304   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
3305   return NULL;
3306 }
3307
3308
3309 SWIGINTERN PyObject *_wrap_delete_Dn(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3310   PyObject *resultobj = 0;
3311   ldb_dn *arg1 = (ldb_dn *) 0 ;
3312   void *argp1 = 0 ;
3313   int res1 = 0 ;
3314   PyObject *swig_obj[1] ;
3315
3316   if (!args) SWIG_fail;
3317   swig_obj[0] = args;
3318   res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ldb_dn, SWIG_POINTER_DISOWN |  0 );
3319   if (!SWIG_IsOK(res1)) {
3320     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Dn" "', argument " "1"" of type '" "ldb_dn *""'");
3321   }
3322   arg1 = (ldb_dn *)(argp1);
3323   delete_ldb_dn(arg1);
3324
3325   resultobj = SWIG_Py_Void();
3326   return resultobj;
3327 fail:
3328   return NULL;
3329 }
3330
3331
3332 SWIGINTERN PyObject *_wrap_Dn_validate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3333   PyObject *resultobj = 0;
3334   ldb_dn *arg1 = (ldb_dn *) 0 ;
3335   bool result;
3336   void *argp1 = 0 ;
3337   int res1 = 0 ;
3338   PyObject *swig_obj[1] ;
3339
3340   if (!args) SWIG_fail;
3341   swig_obj[0] = args;
3342   res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ldb_dn, 0 |  0 );
3343   if (!SWIG_IsOK(res1)) {
3344     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dn_validate" "', argument " "1"" of type '" "ldb_dn *""'");
3345   }
3346   arg1 = (ldb_dn *)(argp1);
3347   result = (bool)ldb_dn_validate(arg1);
3348   resultobj = SWIG_From_bool((bool)(result));
3349   return resultobj;
3350 fail:
3351   return NULL;
3352 }
3353
3354
3355 SWIGINTERN PyObject *_wrap_Dn_get_casefold(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3356   PyObject *resultobj = 0;
3357   ldb_dn *arg1 = (ldb_dn *) 0 ;
3358   char *result = 0 ;
3359   void *argp1 = 0 ;
3360   int res1 = 0 ;
3361   PyObject *swig_obj[1] ;
3362
3363   if (!args) SWIG_fail;
3364   swig_obj[0] = args;
3365   res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ldb_dn, 0 |  0 );
3366   if (!SWIG_IsOK(res1)) {
3367     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dn_get_casefold" "', argument " "1"" of type '" "ldb_dn *""'");
3368   }
3369   arg1 = (ldb_dn *)(argp1);
3370   result = (char *)ldb_dn_get_casefold(arg1);
3371   resultobj = SWIG_FromCharPtr((const char *)result);
3372   return resultobj;
3373 fail:
3374   return NULL;
3375 }
3376
3377
3378 SWIGINTERN PyObject *_wrap_Dn___str__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3379   PyObject *resultobj = 0;
3380   ldb_dn *arg1 = (ldb_dn *) 0 ;
3381   char *result = 0 ;
3382   void *argp1 = 0 ;
3383   int res1 = 0 ;
3384   PyObject *swig_obj[1] ;
3385
3386   if (!args) SWIG_fail;
3387   swig_obj[0] = args;
3388   res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ldb_dn, 0 |  0 );
3389   if (!SWIG_IsOK(res1)) {
3390     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dn___str__" "', argument " "1"" of type '" "ldb_dn *""'");
3391   }
3392   arg1 = (ldb_dn *)(argp1);
3393   result = (char *)ldb_dn_get_linearized(arg1);
3394   resultobj = SWIG_FromCharPtr((const char *)result);
3395   return resultobj;
3396 fail:
3397   return NULL;
3398 }
3399
3400
3401 SWIGINTERN PyObject *_wrap_Dn_parent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3402   PyObject *resultobj = 0;
3403   ldb_dn *arg1 = (ldb_dn *) 0 ;
3404   ldb_dn *result = 0 ;
3405   void *argp1 = 0 ;
3406   int res1 = 0 ;
3407   PyObject *swig_obj[1] ;
3408
3409   if (!args) SWIG_fail;
3410   swig_obj[0] = args;
3411   res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ldb_dn, 0 |  0 );
3412   if (!SWIG_IsOK(res1)) {
3413     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dn_parent" "', argument " "1"" of type '" "ldb_dn *""'");
3414   }
3415   arg1 = (ldb_dn *)(argp1);
3416   result = (ldb_dn *)ldb_dn_parent(arg1);
3417   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ldb_dn, 0 |  0 );
3418   return resultobj;
3419 fail:
3420   return NULL;
3421 }
3422
3423
3424 SWIGINTERN PyObject *_wrap_Dn___cmp__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
3425   PyObject *resultobj = 0;
3426   ldb_dn *arg1 = (ldb_dn *) 0 ;
3427   ldb_dn *arg2 = (ldb_dn *) 0 ;
3428   int result;
3429   void *argp1 = 0 ;
3430   int res1 = 0 ;
3431   void *argp2 = 0 ;
3432   int res2 = 0 ;
3433   PyObject * obj0 = 0 ;
3434   PyObject * obj1 = 0 ;
3435   char *  kwnames[] = {
3436     (char *) "self",(char *) "other", NULL
3437   };
3438
3439   if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Dn___cmp__",kwnames,&obj0,&obj1)) SWIG_fail;
3440   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ldb_dn, 0 |  0 );
3441   if (!SWIG_IsOK(res1)) {
3442     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dn___cmp__" "', argument " "1"" of type '" "ldb_dn *""'");
3443   }
3444   arg1 = (ldb_dn *)(argp1);
3445   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_ldb_dn, 0 |  0 );
3446   if (!SWIG_IsOK(res2)) {
3447     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dn___cmp__" "', argument " "2"" of type '" "ldb_dn *""'");
3448   }
3449   arg2 = (ldb_dn *)(argp2);
3450   result = (int)ldb_dn_compare(arg1,arg2);
3451   resultobj = SWIG_From_int((int)(result));
3452   return resultobj;
3453 fail:
3454   return NULL;
3455 }
3456
3457
3458 SWIGINTERN PyObject *_wrap_Dn_is_valid(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3459   PyObject *resultobj = 0;
3460   ldb_dn *arg1 = (ldb_dn *) 0 ;
3461   bool result;
3462   void *argp1 = 0 ;
3463   int res1 = 0 ;
3464   PyObject *swig_obj[1] ;
3465
3466   if (!args) SWIG_fail;
3467   swig_obj[0] = args;
3468   res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ldb_dn, 0 |  0 );
3469   if (!SWIG_IsOK(res1)) {
3470     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dn_is_valid" "', argument " "1"" of type '" "ldb_dn *""'");
3471   }
3472   arg1 = (ldb_dn *)(argp1);
3473   result = (bool)ldb_dn_is_valid(arg1);
3474   resultobj = SWIG_From_bool((bool)(result));
3475   return resultobj;
3476 fail:
3477   return NULL;
3478 }
3479
3480
3481 SWIGINTERN PyObject *_wrap_Dn_is_special(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3482   PyObject *resultobj = 0;
3483   ldb_dn *arg1 = (ldb_dn *) 0 ;
3484   bool result;
3485   void *argp1 = 0 ;
3486   int res1 = 0 ;
3487   PyObject *swig_obj[1] ;
3488
3489   if (!args) SWIG_fail;
3490   swig_obj[0] = args;
3491   res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ldb_dn, 0 |  0 );
3492   if (!SWIG_IsOK(res1)) {
3493     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dn_is_special" "', argument " "1"" of type '" "ldb_dn *""'");
3494   }
3495   arg1 = (ldb_dn *)(argp1);
3496   result = (bool)ldb_dn_is_special(arg1);
3497   resultobj = SWIG_From_bool((bool)(result));
3498   return resultobj;
3499 fail:
3500   return NULL;
3501 }
3502
3503
3504 SWIGINTERN PyObject *_wrap_Dn_is_null(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3505   PyObject *resultobj = 0;
3506   ldb_dn *arg1 = (ldb_dn *) 0 ;
3507   bool result;
3508   void *argp1 = 0 ;
3509   int res1 = 0 ;
3510   PyObject *swig_obj[1] ;
3511
3512   if (!args) SWIG_fail;
3513   swig_obj[0] = args;
3514   res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ldb_dn, 0 |  0 );
3515   if (!SWIG_IsOK(res1)) {
3516     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dn_is_null" "', argument " "1"" of type '" "ldb_dn *""'");
3517   }
3518   arg1 = (ldb_dn *)(argp1);
3519   result = (bool)ldb_dn_is_null(arg1);
3520   resultobj = SWIG_From_bool((bool)(result));
3521   return resultobj;
3522 fail:
3523   return NULL;
3524 }
3525
3526
3527 SWIGINTERN PyObject *_wrap_Dn_check_special(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
3528   PyObject *resultobj = 0;
3529   ldb_dn *arg1 = (ldb_dn *) 0 ;
3530   char *arg2 = (char *) 0 ;
3531   bool result;
3532   void *argp1 = 0 ;
3533   int res1 = 0 ;
3534   int res2 ;
3535   char *buf2 = 0 ;
3536   int alloc2 = 0 ;
3537   PyObject * obj0 = 0 ;
3538   PyObject * obj1 = 0 ;
3539   char *  kwnames[] = {
3540     (char *) "self",(char *) "name", NULL
3541   };
3542
3543   if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Dn_check_special",kwnames,&obj0,&obj1)) SWIG_fail;
3544   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ldb_dn, 0 |  0 );
3545   if (!SWIG_IsOK(res1)) {
3546     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dn_check_special" "', argument " "1"" of type '" "ldb_dn *""'");
3547   }
3548   arg1 = (ldb_dn *)(argp1);
3549   res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
3550   if (!SWIG_IsOK(res2)) {
3551     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dn_check_special" "', argument " "2"" of type '" "char const *""'");
3552   }
3553   arg2 = (char *)(buf2);
3554   result = (bool)ldb_dn_check_special(arg1,(char const *)arg2);
3555   resultobj = SWIG_From_bool((bool)(result));
3556   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
3557   return resultobj;
3558 fail:
3559   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
3560   return NULL;
3561 }
3562
3563
3564 SWIGINTERN PyObject *_wrap_Dn___len__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3565   PyObject *resultobj = 0;
3566   ldb_dn *arg1 = (ldb_dn *) 0 ;
3567   int result;
3568   void *argp1 = 0 ;
3569   int res1 = 0 ;
3570   PyObject *swig_obj[1] ;
3571
3572   if (!args) SWIG_fail;
3573   swig_obj[0] = args;
3574   res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ldb_dn, 0 |  0 );
3575   if (!SWIG_IsOK(res1)) {
3576     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dn___len__" "', argument " "1"" of type '" "ldb_dn *""'");
3577   }
3578   arg1 = (ldb_dn *)(argp1);
3579   result = (int)ldb_dn_get_comp_num(arg1);
3580   resultobj = SWIG_From_int((int)(result));
3581   return resultobj;
3582 fail:
3583   return NULL;
3584 }
3585
3586
3587 SWIGINTERN PyObject *_wrap_Dn_add_child(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
3588   PyObject *resultobj = 0;
3589   ldb_dn *arg1 = (ldb_dn *) 0 ;
3590   ldb_dn *arg2 = (ldb_dn *) 0 ;
3591   bool result;
3592   void *argp1 = 0 ;
3593   int res1 = 0 ;
3594   void *argp2 = 0 ;
3595   int res2 = 0 ;
3596   PyObject * obj0 = 0 ;
3597   PyObject * obj1 = 0 ;
3598   char *  kwnames[] = {
3599     (char *) "self",(char *) "child", NULL
3600   };
3601
3602   if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Dn_add_child",kwnames,&obj0,&obj1)) SWIG_fail;
3603   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ldb_dn, 0 |  0 );
3604   if (!SWIG_IsOK(res1)) {
3605     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dn_add_child" "', argument " "1"" of type '" "ldb_dn *""'");
3606   }
3607   arg1 = (ldb_dn *)(argp1);
3608   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_ldb_dn, 0 |  0 );
3609   if (!SWIG_IsOK(res2)) {
3610     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dn_add_child" "', argument " "2"" of type '" "ldb_dn *""'");
3611   }
3612   arg2 = (ldb_dn *)(argp2);
3613   result = (bool)ldb_dn_add_child(arg1,arg2);
3614   resultobj = SWIG_From_bool((bool)(result));
3615   return resultobj;
3616 fail:
3617   return NULL;
3618 }
3619
3620
3621 SWIGINTERN PyObject *_wrap_Dn_add_base(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
3622   PyObject *resultobj = 0;
3623   ldb_dn *arg1 = (ldb_dn *) 0 ;
3624   ldb_dn *arg2 = (ldb_dn *) 0 ;
3625   bool result;
3626   void *argp1 = 0 ;
3627   int res1 = 0 ;
3628   void *argp2 = 0 ;
3629   int res2 = 0 ;
3630   PyObject * obj0 = 0 ;
3631   PyObject * obj1 = 0 ;
3632   char *  kwnames[] = {
3633     (char *) "self",(char *) "base", NULL
3634   };
3635
3636   if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Dn_add_base",kwnames,&obj0,&obj1)) SWIG_fail;
3637   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ldb_dn, 0 |  0 );
3638   if (!SWIG_IsOK(res1)) {
3639     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dn_add_base" "', argument " "1"" of type '" "ldb_dn *""'");
3640   }
3641   arg1 = (ldb_dn *)(argp1);
3642   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_ldb_dn, 0 |  0 );
3643   if (!SWIG_IsOK(res2)) {
3644     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dn_add_base" "', argument " "2"" of type '" "ldb_dn *""'");
3645   }
3646   arg2 = (ldb_dn *)(argp2);
3647   result = (bool)ldb_dn_add_base(arg1,arg2);
3648   resultobj = SWIG_From_bool((bool)(result));
3649   return resultobj;
3650 fail:
3651   return NULL;
3652 }
3653
3654
3655 SWIGINTERN PyObject *_wrap_Dn_canonical_str(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3656   PyObject *resultobj = 0;
3657   ldb_dn *arg1 = (ldb_dn *) 0 ;
3658   char *result = 0 ;
3659   void *argp1 = 0 ;
3660   int res1 = 0 ;
3661   PyObject *swig_obj[1] ;
3662
3663   if (!args) SWIG_fail;
3664   swig_obj[0] = args;
3665   res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ldb_dn, 0 |  0 );
3666   if (!SWIG_IsOK(res1)) {
3667     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dn_canonical_str" "', argument " "1"" of type '" "ldb_dn *""'");
3668   }
3669   arg1 = (ldb_dn *)(argp1);
3670   result = (char *)ldb_dn_canonical_str(arg1);
3671   resultobj = SWIG_FromCharPtr((const char *)result);
3672   return resultobj;
3673 fail:
3674   return NULL;
3675 }
3676
3677
3678 SWIGINTERN PyObject *_wrap_Dn_canonical_ex_str(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3679   PyObject *resultobj = 0;
3680   ldb_dn *arg1 = (ldb_dn *) 0 ;
3681   char *result = 0 ;
3682   void *argp1 = 0 ;
3683   int res1 = 0 ;
3684   PyObject *swig_obj[1] ;
3685
3686   if (!args) SWIG_fail;
3687   swig_obj[0] = args;
3688   res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ldb_dn, 0 |  0 );
3689   if (!SWIG_IsOK(res1)) {
3690     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dn_canonical_ex_str" "', argument " "1"" of type '" "ldb_dn *""'");
3691   }
3692   arg1 = (ldb_dn *)(argp1);
3693   result = (char *)ldb_dn_canonical_ex_str(arg1);
3694   resultobj = SWIG_FromCharPtr((const char *)result);
3695   return resultobj;
3696 fail:
3697   return NULL;
3698 }
3699
3700
3701 SWIGINTERN PyObject *_wrap_Dn___repr__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3702   PyObject *resultobj = 0;
3703   ldb_dn *arg1 = (ldb_dn *) 0 ;
3704   char *result = 0 ;
3705   void *argp1 = 0 ;
3706   int res1 = 0 ;
3707   PyObject *swig_obj[1] ;
3708
3709   if (!args) SWIG_fail;
3710   swig_obj[0] = args;
3711   res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ldb_dn, 0 |  0 );
3712   if (!SWIG_IsOK(res1)) {
3713     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dn___repr__" "', argument " "1"" of type '" "ldb_dn *""'");
3714   }
3715   arg1 = (ldb_dn *)(argp1);
3716   result = (char *)ldb_dn___repr__(arg1);
3717   resultobj = SWIG_FromCharPtr((const char *)result);
3718   return resultobj;
3719 fail:
3720   return NULL;
3721 }
3722
3723
3724 SWIGINTERN PyObject *_wrap_Dn___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
3725   PyObject *resultobj = 0;
3726   ldb_dn *arg1 = (ldb_dn *) 0 ;
3727   ldb_dn *arg2 = (ldb_dn *) 0 ;
3728   ldb_dn *result = 0 ;
3729   void *argp1 = 0 ;
3730   int res1 = 0 ;
3731   void *argp2 = 0 ;
3732   int res2 = 0 ;
3733   PyObject * obj0 = 0 ;
3734   PyObject * obj1 = 0 ;
3735   char *  kwnames[] = {
3736     (char *) "self",(char *) "other", NULL
3737   };
3738
3739   if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Dn___add__",kwnames,&obj0,&obj1)) SWIG_fail;
3740   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ldb_dn, 0 |  0 );
3741   if (!SWIG_IsOK(res1)) {
3742     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dn___add__" "', argument " "1"" of type '" "ldb_dn *""'");
3743   }
3744   arg1 = (ldb_dn *)(argp1);
3745   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_ldb_dn, 0 |  0 );
3746   if (!SWIG_IsOK(res2)) {
3747     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dn___add__" "', argument " "2"" of type '" "ldb_dn *""'");
3748   }
3749   arg2 = (ldb_dn *)(argp2);
3750   result = (ldb_dn *)ldb_dn___add__(arg1,arg2);
3751   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ldb_dn, 0 |  0 );
3752   return resultobj;
3753 fail:
3754   return NULL;
3755 }
3756
3757
3758 SWIGINTERN PyObject *Dn_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3759   PyObject *obj;
3760   if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
3761   SWIG_TypeNewClientData(SWIGTYPE_p_ldb_dn, SWIG_NewClientData(obj));
3762   return SWIG_Py_Void();
3763 }
3764
3765 SWIGINTERN PyObject *Dn_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3766   return SWIG_Python_InitShadowInstance(args);
3767 }
3768
3769 SWIGINTERN PyObject *_wrap_MessageElement___cmp__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
3770   PyObject *resultobj = 0;
3771   ldb_message_element *arg1 = (ldb_message_element *) 0 ;
3772   ldb_message_element *arg2 = (ldb_message_element *) 0 ;
3773   int result;
3774   void *argp1 = 0 ;
3775   int res1 = 0 ;
3776   void *argp2 = 0 ;
3777   int res2 = 0 ;
3778   PyObject * obj0 = 0 ;
3779   PyObject * obj1 = 0 ;
3780   char *  kwnames[] = {
3781     (char *) "self",(char *) "other", NULL
3782   };
3783
3784   if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MessageElement___cmp__",kwnames,&obj0,&obj1)) SWIG_fail;
3785   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ldb_message_element, 0 |  0 );
3786   if (!SWIG_IsOK(res1)) {
3787     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MessageElement___cmp__" "', argument " "1"" of type '" "ldb_message_element *""'");
3788   }
3789   arg1 = (ldb_message_element *)(argp1);
3790   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_ldb_message_element, 0 |  0 );
3791   if (!SWIG_IsOK(res2)) {
3792     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MessageElement___cmp__" "', argument " "2"" of type '" "ldb_message_element *""'");
3793   }
3794   arg2 = (ldb_message_element *)(argp2);
3795   result = (int)ldb_message_element___cmp__(arg1,arg2);
3796   resultobj = SWIG_From_int((int)(result));
3797   return resultobj;
3798 fail:
3799   return NULL;
3800 }
3801
3802
3803 SWIGINTERN PyObject *_wrap_MessageElement___iter__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3804   PyObject *resultobj = 0;
3805   ldb_message_element *arg1 = (ldb_message_element *) 0 ;
3806   PyObject *result = 0 ;
3807   void *argp1 = 0 ;
3808   int res1 = 0 ;
3809   PyObject *swig_obj[1] ;
3810
3811   if (!args) SWIG_fail;
3812   swig_obj[0] = args;
3813   res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ldb_message_element, 0 |  0 );
3814   if (!SWIG_IsOK(res1)) {
3815     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MessageElement___iter__" "', argument " "1"" of type '" "ldb_message_element *""'");
3816   }
3817   arg1 = (ldb_message_element *)(argp1);
3818   result = (PyObject *)ldb_message_element___iter__(arg1);
3819   resultobj = result;
3820   return resultobj;
3821 fail:
3822   return NULL;
3823 }
3824
3825
3826 SWIGINTERN PyObject *_wrap_MessageElement___set__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3827   PyObject *resultobj = 0;
3828   ldb_message_element *arg1 = (ldb_message_element *) 0 ;
3829   PyObject *result = 0 ;
3830   void *argp1 = 0 ;
3831   int res1 = 0 ;
3832   PyObject *swig_obj[1] ;
3833
3834   if (!args) SWIG_fail;
3835   swig_obj[0] = args;
3836   res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ldb_message_element, 0 |  0 );
3837   if (!SWIG_IsOK(res1)) {
3838     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MessageElement___set__" "', argument " "1"" of type '" "ldb_message_element *""'");
3839   }
3840   arg1 = (ldb_message_element *)(argp1);
3841   result = (PyObject *)ldb_message_element___set__(arg1);
3842   resultobj = result;
3843   return resultobj;
3844 fail:
3845   return NULL;
3846 }
3847
3848
3849 SWIGINTERN PyObject *_wrap_new_MessageElement(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
3850   PyObject *resultobj = 0;
3851   PyObject *arg1 = (PyObject *) 0 ;
3852   int arg2 = (int) 0 ;
3853   char *arg3 = (char *) NULL ;
3854   ldb_message_element *result = 0 ;
3855   int val2 ;
3856   int ecode2 = 0 ;
3857   int res3 ;
3858   char *buf3 = 0 ;
3859   int alloc3 = 0 ;
3860   PyObject * obj0 = 0 ;
3861   PyObject * obj1 = 0 ;
3862   PyObject * obj2 = 0 ;
3863   char *  kwnames[] = {
3864     (char *) "set_obj",(char *) "flags",(char *) "name", NULL
3865   };
3866
3867   if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:new_MessageElement",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
3868   arg1 = obj0;
3869   if (obj1) {
3870     ecode2 = SWIG_AsVal_int(obj1, &val2);
3871     if (!SWIG_IsOK(ecode2)) {
3872       SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_MessageElement" "', argument " "2"" of type '" "int""'");
3873     }
3874     arg2 = (int)(val2);
3875   }
3876   if (obj2) {
3877     res3 = SWIG_AsCharPtrAndSize(obj2, &buf3, NULL, &alloc3);
3878     if (!SWIG_IsOK(res3)) {
3879       SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_MessageElement" "', argument " "3"" of type '" "char const *""'");
3880     }
3881     arg3 = (char *)(buf3);
3882   }
3883   result = (ldb_message_element *)new_ldb_message_element(arg1,arg2,(char const *)arg3);
3884   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ldb_message_element, SWIG_POINTER_NEW |  0 );
3885   if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
3886   return resultobj;
3887 fail:
3888   if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
3889   return NULL;
3890 }
3891
3892
3893 SWIGINTERN PyObject *_wrap_MessageElement___len__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3894   PyObject *resultobj = 0;
3895   ldb_message_element *arg1 = (ldb_message_element *) 0 ;
3896   int result;
3897   void *argp1 = 0 ;
3898   int res1 = 0 ;
3899   PyObject *swig_obj[1] ;
3900
3901   if (!args) SWIG_fail;
3902   swig_obj[0] = args;
3903   res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ldb_message_element, 0 |  0 );
3904   if (!SWIG_IsOK(res1)) {
3905     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MessageElement___len__" "', argument " "1"" of type '" "ldb_message_element *""'");
3906   }
3907   arg1 = (ldb_message_element *)(argp1);
3908   result = (int)ldb_message_element___len__(arg1);
3909   resultobj = SWIG_From_int((int)(result));
3910   return resultobj;
3911 fail:
3912   return NULL;
3913 }
3914
3915
3916 SWIGINTERN PyObject *_wrap_MessageElement_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
3917   PyObject *resultobj = 0;
3918   ldb_message_element *arg1 = (ldb_message_element *) 0 ;
3919   int arg2 ;
3920   PyObject *result = 0 ;
3921   void *argp1 = 0 ;
3922   int res1 = 0 ;
3923   int val2 ;
3924   int ecode2 = 0 ;
3925   PyObject * obj0 = 0 ;
3926   PyObject * obj1 = 0 ;
3927   char *  kwnames[] = {
3928     (char *) "self",(char *) "i", NULL
3929   };
3930
3931   if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MessageElement_get",kwnames,&obj0,&obj1)) SWIG_fail;
3932   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ldb_message_element, 0 |  0 );
3933   if (!SWIG_IsOK(res1)) {
3934     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MessageElement_get" "', argument " "1"" of type '" "ldb_message_element *""'");
3935   }
3936   arg1 = (ldb_message_element *)(argp1);
3937   ecode2 = SWIG_AsVal_int(obj1, &val2);
3938   if (!SWIG_IsOK(ecode2)) {
3939     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MessageElement_get" "', argument " "2"" of type '" "int""'");
3940   }
3941   arg2 = (int)(val2);
3942   result = (PyObject *)ldb_message_element_get(arg1,arg2);
3943   resultobj = result;
3944   return resultobj;
3945 fail:
3946   return NULL;
3947 }
3948
3949
3950 SWIGINTERN PyObject *_wrap_delete_MessageElement(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3951   PyObject *resultobj = 0;
3952   ldb_message_element *arg1 = (ldb_message_element *) 0 ;
3953   void *argp1 = 0 ;
3954   int res1 = 0 ;
3955   PyObject *swig_obj[1] ;
3956
3957   if (!args) SWIG_fail;
3958   swig_obj[0] = args;
3959   res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ldb_message_element, SWIG_POINTER_DISOWN |  0 );
3960   if (!SWIG_IsOK(res1)) {
3961     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MessageElement" "', argument " "1"" of type '" "ldb_message_element *""'");
3962   }
3963   arg1 = (ldb_message_element *)(argp1);
3964   delete_ldb_message_element(arg1);
3965
3966   resultobj = SWIG_Py_Void();
3967   return resultobj;
3968 fail:
3969   return NULL;
3970 }
3971
3972
3973 SWIGINTERN PyObject *MessageElement_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3974   PyObject *obj;
3975   if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
3976   SWIG_TypeNewClientData(SWIGTYPE_p_ldb_message_element, SWIG_NewClientData(obj));
3977   return SWIG_Py_Void();
3978 }
3979
3980 SWIGINTERN PyObject *MessageElement_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3981   return SWIG_Python_InitShadowInstance(args);
3982 }
3983
3984 SWIGINTERN PyObject *_wrap_ldb_msg_list_elements(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
3985   PyObject *resultobj = 0;
3986   ldb_msg *arg1 = (ldb_msg *) 0 ;
3987   PyObject *result = 0 ;
3988   void *argp1 = 0 ;
3989   int res1 = 0 ;
3990   PyObject * obj0 = 0 ;
3991   char *  kwnames[] = {
3992     (char *) "msg", NULL
3993   };
3994
3995   if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ldb_msg_list_elements",kwnames,&obj0)) SWIG_fail;
3996   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ldb_message, 0 |  0 );
3997   if (!SWIG_IsOK(res1)) {
3998     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ldb_msg_list_elements" "', argument " "1"" of type '" "ldb_msg *""'");
3999   }
4000   arg1 = (ldb_msg *)(argp1);
4001   if (arg1 == NULL)
4002   SWIG_exception(SWIG_ValueError,
4003     "Message can not be None");
4004   result = (PyObject *)ldb_msg_list_elements(arg1);
4005   resultobj = result;
4006   return resultobj;
4007 fail:
4008   return NULL;
4009 }
4010
4011
4012 SWIGINTERN PyObject *_wrap_Message_dn_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4013   PyObject *resultobj = 0;
4014   ldb_msg *arg1 = (ldb_msg *) 0 ;
4015   ldb_dn *arg2 = (ldb_dn *) 0 ;
4016   void *argp1 = 0 ;
4017   int res1 = 0 ;
4018   void *argp2 = 0 ;
4019   int res2 = 0 ;
4020   PyObject *swig_obj[2] ;
4021
4022   if (!SWIG_Python_UnpackTuple(args,"Message_dn_set",2,2,swig_obj)) SWIG_fail;
4023   res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ldb_message, 0 |  0 );
4024   if (!SWIG_IsOK(res1)) {
4025     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Message_dn_set" "', argument " "1"" of type '" "ldb_msg *""'");
4026   }
4027   arg1 = (ldb_msg *)(argp1);
4028   res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_ldb_dn, SWIG_POINTER_DISOWN |  0 );
4029   if (!SWIG_IsOK(res2)) {
4030     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Message_dn_set" "', argument " "2"" of type '" "ldb_dn *""'");
4031   }
4032   arg2 = (ldb_dn *)(argp2);
4033   if (arg1 == NULL)
4034   SWIG_exception(SWIG_ValueError,
4035     "Message can not be None");
4036   if (arg1) (arg1)->dn = arg2;
4037
4038   resultobj = SWIG_Py_Void();
4039   return resultobj;
4040 fail:
4041   return NULL;
4042 }
4043
4044
4045 SWIGINTERN PyObject *_wrap_Message_dn_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4046   PyObject *resultobj = 0;
4047   ldb_msg *arg1 = (ldb_msg *) 0 ;
4048   ldb_dn *result = 0 ;
4049   void *argp1 = 0 ;
4050   int res1 = 0 ;
4051   PyObject *swig_obj[1] ;
4052
4053   if (!args) SWIG_fail;
4054   swig_obj[0] = args;
4055   res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ldb_message, 0 |  0 );
4056   if (!SWIG_IsOK(res1)) {
4057     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Message_dn_get" "', argument " "1"" of type '" "ldb_msg *""'");
4058   }
4059   arg1 = (ldb_msg *)(argp1);
4060   if (arg1 == NULL)
4061   SWIG_exception(SWIG_ValueError,
4062     "Message can not be None");
4063   result = (ldb_dn *) ((arg1)->dn);
4064   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ldb_dn, 0 |  0 );
4065   return resultobj;
4066 fail:
4067   return NULL;
4068 }
4069
4070
4071 SWIGINTERN PyObject *_wrap_new_Message(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4072   PyObject *resultobj = 0;
4073   ldb_dn *arg1 = (ldb_dn *) NULL ;
4074   ldb_msg *result = 0 ;
4075   void *argp1 = 0 ;
4076   int res1 = 0 ;
4077   PyObject * obj0 = 0 ;
4078   char *  kwnames[] = {
4079     (char *) "dn", NULL
4080   };
4081
4082   if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_Message",kwnames,&obj0)) SWIG_fail;
4083   if (obj0) {
4084     res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ldb_dn, 0 |  0 );
4085     if (!SWIG_IsOK(res1)) {
4086       SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Message" "', argument " "1"" of type '" "ldb_dn *""'");
4087     }
4088     arg1 = (ldb_dn *)(argp1);
4089   }
4090   result = (ldb_msg *)new_ldb_msg(arg1);
4091   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ldb_message, SWIG_POINTER_NEW |  0 );
4092   return resultobj;
4093 fail:
4094   return NULL;
4095 }
4096
4097
4098 SWIGINTERN PyObject *_wrap_delete_Message(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4099   PyObject *resultobj = 0;
4100   ldb_msg *arg1 = (ldb_msg *) 0 ;
4101   void *argp1 = 0 ;
4102   int res1 = 0 ;
4103   PyObject *swig_obj[1] ;
4104
4105   if (!args) SWIG_fail;
4106   swig_obj[0] = args;
4107   res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ldb_message, SWIG_POINTER_DISOWN |  0 );
4108   if (!SWIG_IsOK(res1)) {
4109     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Message" "', argument " "1"" of type '" "ldb_msg *""'");
4110   }
4111   arg1 = (ldb_msg *)(argp1);
4112   if (arg1 == NULL)
4113   SWIG_exception(SWIG_ValueError,
4114     "Message can not be None");
4115   delete_ldb_msg(arg1);
4116
4117   resultobj = SWIG_Py_Void();
4118   return resultobj;
4119 fail:
4120   return NULL;
4121 }
4122
4123
4124 SWIGINTERN PyObject *_wrap_Message_find_element(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4125   PyObject *resultobj = 0;
4126   ldb_msg *arg1 = (ldb_msg *) 0 ;
4127   char *arg2 = (char *) 0 ;
4128   ldb_message_element *result = 0 ;
4129   void *argp1 = 0 ;
4130   int res1 = 0 ;
4131   int res2 ;
4132   char *buf2 = 0 ;
4133   int alloc2 = 0 ;
4134   PyObject * obj0 = 0 ;
4135   PyObject * obj1 = 0 ;
4136   char *  kwnames[] = {
4137     (char *) "self",(char *) "name", NULL
4138   };
4139
4140   if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Message_find_element",kwnames,&obj0,&obj1)) SWIG_fail;
4141   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ldb_message, 0 |  0 );
4142   if (!SWIG_IsOK(res1)) {
4143     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Message_find_element" "', argument " "1"" of type '" "ldb_msg *""'");
4144   }
4145   arg1 = (ldb_msg *)(argp1);
4146   res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
4147   if (!SWIG_IsOK(res2)) {
4148     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Message_find_element" "', argument " "2"" of type '" "char const *""'");
4149   }
4150   arg2 = (char *)(buf2);
4151   if (arg1 == NULL)
4152   SWIG_exception(SWIG_ValueError,
4153     "Message can not be None");
4154   result = (ldb_message_element *)ldb_msg_find_element(arg1,(char const *)arg2);
4155   {
4156     if (result == NULL)
4157     PyErr_SetString(PyExc_KeyError, "no such element");
4158     else
4159     resultobj = SWIG_NewPointerObj(result, SWIGTYPE_p_ldb_message_element, 0);
4160   }
4161   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
4162   return resultobj;
4163 fail:
4164   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
4165   return NULL;
4166 }
4167
4168
4169 SWIGINTERN PyObject *_wrap_Message___setitem____SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
4170   PyObject *resultobj = 0;
4171   ldb_msg *arg1 = (ldb_msg *) 0 ;
4172   char *arg2 = (char *) 0 ;
4173   ldb_message_element *arg3 = (ldb_message_element *) 0 ;
4174   void *argp1 = 0 ;
4175   int res1 = 0 ;
4176   int res2 ;
4177   char *buf2 = 0 ;
4178   int alloc2 = 0 ;
4179   void *argp3 = 0 ;
4180   int res3 = 0 ;
4181
4182   if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
4183   res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ldb_message, 0 |  0 );
4184   if (!SWIG_IsOK(res1)) {
4185     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Message___setitem__" "', argument " "1"" of type '" "ldb_msg *""'");
4186   }
4187   arg1 = (ldb_msg *)(argp1);
4188   res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
4189   if (!SWIG_IsOK(res2)) {
4190     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Message___setitem__" "', argument " "2"" of type '" "char const *""'");
4191   }
4192   arg2 = (char *)(buf2);
4193   res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_ldb_message_element, 0 |  0 );
4194   if (!SWIG_IsOK(res3)) {
4195     SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Message___setitem__" "', argument " "3"" of type '" "ldb_message_element *""'");
4196   }
4197   arg3 = (ldb_message_element *)(argp3);
4198   if (arg1 == NULL)
4199   SWIG_exception(SWIG_ValueError,
4200     "Message can not be None");
4201   ldb_msg___setitem____SWIG_0(arg1,(char const *)arg2,arg3);
4202   resultobj = SWIG_Py_Void();
4203   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
4204   return resultobj;
4205 fail:
4206   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
4207   return NULL;
4208 }
4209
4210
4211 SWIGINTERN PyObject *_wrap_Message___setitem____SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
4212   PyObject *resultobj = 0;
4213   ldb_msg *arg1 = (ldb_msg *) 0 ;
4214   char *arg2 = (char *) 0 ;
4215   PyObject *arg3 = (PyObject *) 0 ;
4216   void *argp1 = 0 ;
4217   int res1 = 0 ;
4218   int res2 ;
4219   char *buf2 = 0 ;
4220   int alloc2 = 0 ;
4221
4222   if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
4223   res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ldb_message, 0 |  0 );
4224   if (!SWIG_IsOK(res1)) {
4225     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Message___setitem__" "', argument " "1"" of type '" "ldb_msg *""'");
4226   }
4227   arg1 = (ldb_msg *)(argp1);
4228   res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
4229   if (!SWIG_IsOK(res2)) {
4230     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Message___setitem__" "', argument " "2"" of type '" "char const *""'");
4231   }
4232   arg2 = (char *)(buf2);
4233   arg3 = swig_obj[2];
4234   if (arg1 == NULL)
4235   SWIG_exception(SWIG_ValueError,
4236     "Message can not be None");
4237   ldb_msg___setitem____SWIG_1(arg1,(char const *)arg2,arg3);
4238   resultobj = SWIG_Py_Void();
4239   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
4240   return resultobj;
4241 fail:
4242   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
4243   return NULL;
4244 }
4245
4246
4247 SWIGINTERN PyObject *_wrap_Message___setitem__(PyObject *self, PyObject *args) {
4248   int argc;
4249   PyObject *argv[4];
4250
4251   if (!(argc = SWIG_Python_UnpackTuple(args,"Message___setitem__",0,3,argv))) SWIG_fail;
4252   --argc;
4253   if (argc == 3) {
4254     int _v = 0;
4255     {
4256       void *vptr = 0;
4257       int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_ldb_message_element, 0);
4258       _v = SWIG_CheckState(res);
4259     }
4260     if (!_v) goto check_1;
4261     return _wrap_Message___setitem____SWIG_0(self, argc, argv);
4262   }
4263 check_1:
4264
4265   if (argc == 3) {
4266     return _wrap_Message___setitem____SWIG_1(self, argc, argv);
4267   }
4268
4269 fail:
4270   SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'Message___setitem__'.\n"
4271     "  Possible C/C++ prototypes are:\n"
4272     "    __setitem__(ldb_msg *,char const *,ldb_message_element *)\n"
4273     "    __setitem__(ldb_msg *,char const *,PyObject *)\n");
4274   return NULL;
4275 }
4276
4277
4278 SWIGINTERN PyObject *_wrap_Message___len__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4279   PyObject *resultobj = 0;
4280   ldb_msg *arg1 = (ldb_msg *) 0 ;
4281   unsigned int result;
4282   void *argp1 = 0 ;
4283   int res1 = 0 ;
4284   PyObject *swig_obj[1] ;
4285
4286   if (!args) SWIG_fail;
4287   swig_obj[0] = args;
4288   res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ldb_message, 0 |  0 );
4289   if (!SWIG_IsOK(res1)) {
4290     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Message___len__" "', argument " "1"" of type '" "ldb_msg *""'");
4291   }
4292   arg1 = (ldb_msg *)(argp1);
4293   if (arg1 == NULL)
4294   SWIG_exception(SWIG_ValueError,
4295     "Message can not be None");
4296   result = (unsigned int)ldb_msg___len__(arg1);
4297   resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
4298   return resultobj;
4299 fail:
4300   return NULL;
4301 }
4302
4303
4304 SWIGINTERN PyObject *_wrap_Message_keys(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4305   PyObject *resultobj = 0;
4306   ldb_msg *arg1 = (ldb_msg *) 0 ;
4307   PyObject *result = 0 ;
4308   void *argp1 = 0 ;
4309   int res1 = 0 ;
4310   PyObject *swig_obj[1] ;
4311
4312   if (!args) SWIG_fail;
4313   swig_obj[0] = args;
4314   res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ldb_message, 0 |  0 );
4315   if (!SWIG_IsOK(res1)) {
4316     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Message_keys" "', argument " "1"" of type '" "ldb_msg *""'");
4317   }
4318   arg1 = (ldb_msg *)(argp1);
4319   if (arg1 == NULL)
4320   SWIG_exception(SWIG_ValueError,
4321     "Message can not be None");
4322   result = (PyObject *)ldb_msg_keys(arg1);
4323   resultobj = result;
4324   return resultobj;
4325 fail:
4326   return NULL;
4327 }
4328
4329
4330 SWIGINTERN PyObject *_wrap_Message___iter__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4331   PyObject *resultobj = 0;
4332   ldb_msg *arg1 = (ldb_msg *) 0 ;
4333   PyObject *result = 0 ;
4334   void *argp1 = 0 ;
4335   int res1 = 0 ;
4336   PyObject *swig_obj[1] ;
4337
4338   if (!args) SWIG_fail;
4339   swig_obj[0] = args;
4340   res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ldb_message, 0 |  0 );
4341   if (!SWIG_IsOK(res1)) {
4342     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Message___iter__" "', argument " "1"" of type '" "ldb_msg *""'");
4343   }
4344   arg1 = (ldb_msg *)(argp1);
4345   if (arg1 == NULL)
4346   SWIG_exception(SWIG_ValueError,
4347     "Message can not be None");
4348   result = (PyObject *)ldb_msg___iter__(arg1);
4349   resultobj = result;
4350   return resultobj;
4351 fail:
4352   return NULL;
4353 }
4354
4355
4356 SWIGINTERN PyObject *_wrap_Message___delitem__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4357   PyObject *resultobj = 0;
4358   ldb_msg *arg1 = (ldb_msg *) 0 ;
4359   char *arg2 = (char *) 0 ;
4360   void *argp1 = 0 ;
4361   int res1 = 0 ;
4362   int res2 ;
4363   char *buf2 = 0 ;
4364   int alloc2 = 0 ;
4365   PyObject * obj0 = 0 ;
4366   PyObject * obj1 = 0 ;
4367   char *  kwnames[] = {
4368     (char *) "self",(char *) "name", NULL
4369   };
4370
4371   if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Message___delitem__",kwnames,&obj0,&obj1)) SWIG_fail;
4372   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ldb_message, 0 |  0 );
4373   if (!SWIG_IsOK(res1)) {
4374     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Message___delitem__" "', argument " "1"" of type '" "ldb_msg *""'");
4375   }
4376   arg1 = (ldb_msg *)(argp1);
4377   res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
4378   if (!SWIG_IsOK(res2)) {
4379     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Message___delitem__" "', argument " "2"" of type '" "char const *""'");
4380   }
4381   arg2 = (char *)(buf2);
4382   if (arg1 == NULL)
4383   SWIG_exception(SWIG_ValueError,
4384     "Message can not be None");
4385   ldb_msg_remove_attr(arg1,(char const *)arg2);
4386   resultobj = SWIG_Py_Void();
4387   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
4388   return resultobj;
4389 fail:
4390   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
4391   return NULL;
4392 }
4393
4394
4395 SWIGINTERN PyObject *Message_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4396   PyObject *obj;
4397   if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
4398   SWIG_TypeNewClientData(SWIGTYPE_p_ldb_message, SWIG_NewClientData(obj));
4399   return SWIG_Py_Void();
4400 }
4401
4402 SWIGINTERN PyObject *Message_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4403   return SWIG_Python_InitShadowInstance(args);
4404 }
4405
4406 SWIGINTERN PyObject *_wrap_ldb_ldif_to_pyobject(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4407   PyObject *resultobj = 0;
4408   ldb_ldif *arg1 = (ldb_ldif *) 0 ;
4409   PyObject *result = 0 ;
4410   void *argp1 = 0 ;
4411   int res1 = 0 ;
4412   PyObject * obj0 = 0 ;
4413   char *  kwnames[] = {
4414     (char *) "ldif", NULL
4415   };
4416
4417   if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ldb_ldif_to_pyobject",kwnames,&obj0)) SWIG_fail;
4418   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ldb_ldif, 0 |  0 );
4419   if (!SWIG_IsOK(res1)) {
4420     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ldb_ldif_to_pyobject" "', argument " "1"" of type '" "ldb_ldif *""'");
4421   }
4422   arg1 = (ldb_ldif *)(argp1);
4423   result = (PyObject *)ldb_ldif_to_pyobject(arg1);
4424   resultobj = result;
4425   return resultobj;
4426 fail:
4427   return NULL;
4428 }
4429
4430
4431 SWIGINTERN PyObject *_wrap_new_Ldb(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4432   PyObject *resultobj = 0;
4433   ldb *result = 0 ;
4434
4435   if (!SWIG_Python_UnpackTuple(args,"new_Ldb",0,0,0)) SWIG_fail;
4436   result = (ldb *)new_ldb();
4437   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ldb_context, SWIG_POINTER_NEW |  0 );
4438   return resultobj;
4439 fail:
4440   return NULL;
4441 }
4442
4443
4444 SWIGINTERN PyObject *_wrap_Ldb_connect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4445   PyObject *resultobj = 0;
4446   ldb *arg1 = (ldb *) 0 ;
4447   char *arg2 = (char *) 0 ;
4448   unsigned int arg3 = (unsigned int) 0 ;
4449   char **arg4 = (char **) (char **)NULL ;
4450   ldb_error result;
4451   void *argp1 = 0 ;
4452   int res1 = 0 ;
4453   int res2 ;
4454   char *buf2 = 0 ;
4455   int alloc2 = 0 ;
4456   unsigned int val3 ;
4457   int ecode3 = 0 ;
4458   void *argp4 = 0 ;
4459   int res4 = 0 ;
4460   PyObject * obj0 = 0 ;
4461   PyObject * obj1 = 0 ;
4462   PyObject * obj2 = 0 ;
4463   PyObject * obj3 = 0 ;
4464   char *  kwnames[] = {
4465     (char *) "self",(char *) "url",(char *) "flags",(char *) "options", NULL
4466   };
4467
4468   if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Ldb_connect",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
4469   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ldb_context, 0 |  0 );
4470   if (!SWIG_IsOK(res1)) {
4471     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Ldb_connect" "', argument " "1"" of type '" "ldb *""'");
4472   }
4473   arg1 = (ldb *)(argp1);
4474   res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
4475   if (!SWIG_IsOK(res2)) {
4476     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Ldb_connect" "', argument " "2"" of type '" "char const *""'");
4477   }
4478   arg2 = (char *)(buf2);
4479   if (obj2) {
4480     ecode3 = SWIG_AsVal_unsigned_SS_int(obj2, &val3);
4481     if (!SWIG_IsOK(ecode3)) {
4482       SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Ldb_connect" "', argument " "3"" of type '" "unsigned int""'");
4483     }
4484     arg3 = (unsigned int)(val3);
4485   }
4486   if (obj3) {
4487     res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_p_char, 0 |  0 );
4488     if (!SWIG_IsOK(res4)) {
4489       SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Ldb_connect" "', argument " "4"" of type '" "char const *[]""'");
4490     }
4491     arg4 = (char **)(argp4);
4492   }
4493   if (arg1 == NULL)
4494   SWIG_exception(SWIG_ValueError,
4495     "ldb context must be non-NULL");
4496   result = ldb_connect(arg1,(char const *)arg2,arg3,(char const *(*))arg4);
4497   if (result != 0) {
4498     PyErr_SetObject(PyExc_LdbError, Py_BuildValue((char *)"(i,s)", result, ldb_errstring(arg1)));
4499     SWIG_fail;
4500   }
4501   resultobj = Py_None;
4502   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
4503   return resultobj;
4504 fail:
4505   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
4506   return NULL;
4507 }
4508
4509
4510 SWIGINTERN PyObject *_wrap_delete_Ldb(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4511   PyObject *resultobj = 0;
4512   ldb *arg1 = (ldb *) 0 ;
4513   void *argp1 = 0 ;
4514   int res1 = 0 ;
4515   PyObject *swig_obj[1] ;
4516
4517   if (!args) SWIG_fail;
4518   swig_obj[0] = args;
4519   res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ldb_context, SWIG_POINTER_DISOWN |  0 );
4520   if (!SWIG_IsOK(res1)) {
4521     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Ldb" "', argument " "1"" of type '" "ldb *""'");
4522   }
4523   arg1 = (ldb *)(argp1);
4524   if (arg1 == NULL)
4525   SWIG_exception(SWIG_ValueError,
4526     "ldb context must be non-NULL");
4527   delete_ldb(arg1);
4528
4529   resultobj = SWIG_Py_Void();
4530   return resultobj;
4531 fail:
4532   return NULL;
4533 }
4534
4535
4536 SWIGINTERN PyObject *_wrap_Ldb_search_ex(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4537   PyObject *resultobj = 0;
4538   ldb *arg1 = (ldb *) 0 ;
4539   TALLOC_CTX *arg2 = (TALLOC_CTX *) 0 ;
4540   ldb_dn *arg3 = (ldb_dn *) NULL ;
4541   enum ldb_scope arg4 = (enum ldb_scope) LDB_SCOPE_DEFAULT ;
4542   char *arg5 = (char *) NULL ;
4543   char **arg6 = (char **) NULL ;
4544   struct ldb_control **arg7 = (struct ldb_control **) NULL ;
4545   struct ldb_result **arg8 = (struct ldb_result **) 0 ;
4546   ldb_error result;
4547   void *argp1 = 0 ;
4548   int res1 = 0 ;
4549   int val4 ;
4550   int ecode4 = 0 ;
4551   int res5 ;
4552   char *buf5 = 0 ;
4553   int alloc5 = 0 ;
4554   void *argp7 = 0 ;
4555   int res7 = 0 ;
4556   struct ldb_result *temp_ldb_result8 ;
4557   int i8 ;
4558   PyObject * obj0 = 0 ;
4559   PyObject * obj1 = 0 ;
4560   PyObject * obj2 = 0 ;
4561   PyObject * obj3 = 0 ;
4562   PyObject * obj4 = 0 ;
4563   PyObject * obj5 = 0 ;
4564   char *  kwnames[] = {
4565     (char *) "self",(char *) "base",(char *) "scope",(char *) "expression",(char *) "attrs",(char *) "controls", NULL
4566   };
4567
4568   arg2 = NULL;
4569   arg8 = &temp_ldb_result8;
4570   if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOO:Ldb_search_ex",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
4571   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ldb_context, 0 |  0 );
4572   if (!SWIG_IsOK(res1)) {
4573     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Ldb_search_ex" "', argument " "1"" of type '" "ldb *""'");
4574   }
4575   arg1 = (ldb *)(argp1);
4576   if (obj1) {
4577     if (ldb_dn_from_pyobject(NULL, obj1, arg1, &arg3) != 0) {
4578       SWIG_fail;
4579     }
4580   }
4581   if (obj2) {
4582     ecode4 = SWIG_AsVal_int(obj2, &val4);
4583     if (!SWIG_IsOK(ecode4)) {
4584       SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Ldb_search_ex" "', argument " "4"" of type '" "enum ldb_scope""'");
4585     }
4586     arg4 = (enum ldb_scope)(val4);
4587   }
4588   if (obj3) {
4589     res5 = SWIG_AsCharPtrAndSize(obj3, &buf5, NULL, &alloc5);
4590     if (!SWIG_IsOK(res5)) {
4591       SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "Ldb_search_ex" "', argument " "5"" of type '" "char const *""'");
4592     }
4593     arg5 = (char *)(buf5);
4594   }
4595   if (obj4) {
4596     if (obj4 == Py_None) {
4597       arg6 = NULL;
4598     } else if (PySequence_Check(obj4)) {
4599       int i;
4600       arg6 = talloc_array(NULL, char *, PySequence_Size(obj4)+1);
4601       for(i = 0; i < PySequence_Size(obj4); i++)
4602       arg6[i] = PyString_AsString(PySequence_GetItem(obj4, i));
4603       arg6[i] = NULL;
4604     } else {
4605       SWIG_exception(SWIG_TypeError, "expected sequence");
4606     }
4607   }
4608   if (obj5) {
4609     res7 = SWIG_ConvertPtr(obj5, &argp7,SWIGTYPE_p_p_ldb_control, 0 |  0 );
4610     if (!SWIG_IsOK(res7)) {
4611       SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "Ldb_search_ex" "', argument " "7"" of type '" "struct ldb_control **""'");
4612     }
4613     arg7 = (struct ldb_control **)(argp7);
4614   }
4615   if (arg1 == NULL)
4616   SWIG_exception(SWIG_ValueError,
4617     "ldb context must be non-NULL");
4618   result = ldb_search_ex(arg1,arg2,arg3,arg4,(char const *)arg5,(char const *const *)arg6,arg7,arg8);
4619   if (result != 0) {
4620     PyErr_SetObject(PyExc_LdbError, Py_BuildValue((char *)"(i,s)", result, ldb_errstring(arg1)));
4621     SWIG_fail;
4622   }
4623   resultobj = Py_None;
4624   resultobj = PyList_New((*arg8)->count);
4625   for (i8 = 0; i8 < (*arg8)->count; i8++) {
4626     PyList_SetItem(resultobj, i8,
4627       SWIG_NewPointerObj((*arg8)->msgs[i8], SWIGTYPE_p_ldb_message, 0)
4628       );
4629   }
4630   talloc_free(arg3);
4631   if (alloc5 == SWIG_NEWOBJ) free((char*)buf5);
4632   talloc_free(arg6);
4633   return resultobj;
4634 fail:
4635   talloc_free(arg3);
4636   if (alloc5 == SWIG_NEWOBJ) free((char*)buf5);
4637   talloc_free(arg6);
4638   return NULL;
4639 }
4640
4641
4642 SWIGINTERN PyObject *_wrap_Ldb_delete(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4643   PyObject *resultobj = 0;
4644   ldb *arg1 = (ldb *) 0 ;
4645   ldb_dn *arg2 = (ldb_dn *) 0 ;
4646   ldb_error result;
4647   void *argp1 = 0 ;
4648   int res1 = 0 ;
4649   PyObject * obj0 = 0 ;
4650   PyObject * obj1 = 0 ;
4651   char *  kwnames[] = {
4652     (char *) "self",(char *) "dn", NULL
4653   };
4654
4655   if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Ldb_delete",kwnames,&obj0,&obj1)) SWIG_fail;
4656   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ldb_context, 0 |  0 );
4657   if (!SWIG_IsOK(res1)) {
4658     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Ldb_delete" "', argument " "1"" of type '" "ldb *""'");
4659   }
4660   arg1 = (ldb *)(argp1);
4661   if (ldb_dn_from_pyobject(NULL, obj1, arg1, &arg2) != 0) {
4662     SWIG_fail;
4663   }
4664   if (arg1 == NULL)
4665   SWIG_exception(SWIG_ValueError,
4666     "ldb context must be non-NULL");
4667   result = ldb_delete(arg1,arg2);
4668   if (result != 0) {
4669     PyErr_SetObject(PyExc_LdbError, Py_BuildValue((char *)"(i,s)", result, ldb_errstring(arg1)));
4670     SWIG_fail;
4671   }
4672   resultobj = Py_None;
4673   talloc_free(arg2);
4674   return resultobj;
4675 fail:
4676   talloc_free(arg2);
4677   return NULL;
4678 }
4679
4680
4681 SWIGINTERN PyObject *_wrap_Ldb_rename(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4682   PyObject *resultobj = 0;
4683   ldb *arg1 = (ldb *) 0 ;
4684   ldb_dn *arg2 = (ldb_dn *) 0 ;
4685   ldb_dn *arg3 = (ldb_dn *) 0 ;
4686   ldb_error result;
4687   void *argp1 = 0 ;
4688   int res1 = 0 ;
4689   PyObject * obj0 = 0 ;
4690   PyObject * obj1 = 0 ;
4691   PyObject * obj2 = 0 ;
4692   char *  kwnames[] = {
4693     (char *) "self",(char *) "olddn",(char *) "newdn", NULL
4694   };
4695
4696   if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Ldb_rename",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
4697   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ldb_context, 0 |  0 );
4698   if (!SWIG_IsOK(res1)) {
4699     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Ldb_rename" "', argument " "1"" of type '" "ldb *""'");
4700   }
4701   arg1 = (ldb *)(argp1);
4702   if (ldb_dn_from_pyobject(NULL, obj1, arg1, &arg2) != 0) {
4703     SWIG_fail;
4704   }
4705   if (ldb_dn_from_pyobject(NULL, obj2, arg1, &arg3) != 0) {
4706     SWIG_fail;
4707   }
4708   if (arg1 == NULL)
4709   SWIG_exception(SWIG_ValueError,
4710     "ldb context must be non-NULL");
4711   result = ldb_rename(arg1,arg2,arg3);
4712   if (result != 0) {
4713     PyErr_SetObject(PyExc_LdbError, Py_BuildValue((char *)"(i,s)", result, ldb_errstring(arg1)));
4714     SWIG_fail;
4715   }
4716   resultobj = Py_None;
4717   talloc_free(arg2);
4718   talloc_free(arg3);
4719   return resultobj;
4720 fail:
4721   talloc_free(arg2);
4722   talloc_free(arg3);
4723   return NULL;
4724 }
4725
4726
4727 SWIGINTERN PyObject *_wrap_Ldb_parse_control_strings(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4728   PyObject *resultobj = 0;
4729   ldb *arg1 = (ldb *) 0 ;
4730   TALLOC_CTX *arg2 = (TALLOC_CTX *) 0 ;
4731   char **arg3 = (char **) 0 ;
4732   struct ldb_control **result = 0 ;
4733   void *argp1 = 0 ;
4734   int res1 = 0 ;
4735   PyObject * obj0 = 0 ;
4736   PyObject * obj1 = 0 ;
4737   char *  kwnames[] = {
4738     (char *) "self",(char *) "control_strings", NULL
4739   };
4740
4741   arg2 = NULL;
4742   if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Ldb_parse_control_strings",kwnames,&obj0,&obj1)) SWIG_fail;
4743   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ldb_context, 0 |  0 );
4744   if (!SWIG_IsOK(res1)) {
4745     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Ldb_parse_control_strings" "', argument " "1"" of type '" "ldb *""'");
4746   }
4747   arg1 = (ldb *)(argp1);
4748   if (obj1 == Py_None) {
4749     arg3 = NULL;
4750   } else if (PySequence_Check(obj1)) {
4751     int i;
4752     arg3 = talloc_array(NULL, char *, PySequence_Size(obj1)+1);
4753     for(i = 0; i < PySequence_Size(obj1); i++)
4754     arg3[i] = PyString_AsString(PySequence_GetItem(obj1, i));
4755     arg3[i] = NULL;
4756   } else {
4757     SWIG_exception(SWIG_TypeError, "expected sequence");
4758   }
4759   if (arg1 == NULL)
4760   SWIG_exception(SWIG_ValueError,
4761     "ldb context must be non-NULL");
4762   result = (struct ldb_control **)ldb_parse_control_strings(arg1,arg2,(char const *const *)arg3);
4763   if (result == NULL) {
4764     PyErr_SetObject(PyExc_LdbError, Py_BuildValue((char *)"(s)", ldb_errstring(arg1)));
4765     SWIG_fail;
4766   }
4767   resultobj = SWIG_NewPointerObj(result, SWIGTYPE_p_p_ldb_control, 0);
4768   talloc_free(arg3);
4769   return resultobj;
4770 fail:
4771   talloc_free(arg3);
4772   return NULL;
4773 }
4774
4775
4776 SWIGINTERN PyObject *_wrap_Ldb_add(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4777   PyObject *resultobj = 0;
4778   ldb *arg1 = (ldb *) 0 ;
4779   ldb_msg *arg2 = (ldb_msg *) 0 ;
4780   ldb_error result;
4781   void *argp1 = 0 ;
4782   int res1 = 0 ;
4783   PyObject * obj0 = 0 ;
4784   PyObject * obj1 = 0 ;
4785   char *  kwnames[] = {
4786     (char *) "self",(char *) "add_msg", NULL
4787   };
4788
4789   if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Ldb_add",kwnames,&obj0,&obj1)) SWIG_fail;
4790   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ldb_context, 0 |  0 );
4791   if (!SWIG_IsOK(res1)) {
4792     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Ldb_add" "', argument " "1"" of type '" "ldb *""'");
4793   }
4794   arg1 = (ldb *)(argp1);
4795   {
4796     Py_ssize_t dict_pos, msg_pos;
4797     ldb_message_element *msgel;
4798     PyObject *key, *value;
4799
4800     if (PyDict_Check(obj1)) {
4801       PyObject *dn_value = PyDict_GetItemString(obj1, "dn");
4802       arg2 = ldb_msg_new(NULL);
4803       arg2->elements = talloc_zero_array(arg2, struct ldb_message_element, PyDict_Size(obj1));
4804       msg_pos = dict_pos = 0;
4805       if (dn_value) {
4806         /* using argp1 (magic SWIG value) here is a hack */
4807         if (ldb_dn_from_pyobject(arg2, dn_value, argp1, &arg2->dn) != 0) {
4808           SWIG_exception(SWIG_TypeError, "unable to import dn object");
4809         }
4810         if (arg2->dn == NULL) {
4811           SWIG_exception(SWIG_TypeError, "dn set but not found");
4812         }
4813       }
4814
4815       while (PyDict_Next(obj1, &dict_pos, &key, &value)) {
4816         char *key_str = PyString_AsString(key);
4817         if (strcmp(key_str, "dn") != 0) {
4818           msgel = ldb_msg_element_from_pyobject(arg2->elements, value, 0, key_str);
4819           if (msgel == NULL) {
4820             SWIG_exception(SWIG_TypeError, "unable to import element");
4821           }
4822           memcpy(&arg2->elements[msg_pos], msgel, sizeof(*msgel));
4823           msg_pos++;
4824         }
4825       }
4826
4827       if (arg2->dn == NULL) {
4828         SWIG_exception(SWIG_TypeError, "no dn set");
4829       }
4830
4831       arg2->num_elements = msg_pos;
4832     } else {
4833       if (SWIG_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_ldb_message, 0) != 0) {
4834         SWIG_exception(SWIG_TypeError, "unable to convert ldb message");
4835       }
4836     }
4837   }
4838   if (arg1 == NULL)
4839   SWIG_exception(SWIG_ValueError,
4840     "ldb context must be non-NULL");
4841   if (arg2 == NULL)
4842   SWIG_exception(SWIG_ValueError,
4843     "Message can not be None");
4844   result = ldb_add(arg1,arg2);
4845   if (result != 0) {
4846     PyErr_SetObject(PyExc_LdbError, Py_BuildValue((char *)"(i,s)", result, ldb_errstring(arg1)));
4847     SWIG_fail;
4848   }
4849   resultobj = Py_None;
4850   return resultobj;
4851 fail:
4852   return NULL;
4853 }
4854
4855
4856 SWIGINTERN PyObject *_wrap_Ldb_modify(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4857   PyObject *resultobj = 0;
4858   ldb *arg1 = (ldb *) 0 ;
4859   ldb_msg *arg2 = (ldb_msg *) 0 ;
4860   ldb_error result;
4861   void *argp1 = 0 ;
4862   int res1 = 0 ;
4863   void *argp2 = 0 ;
4864   int res2 = 0 ;
4865   PyObject * obj0 = 0 ;
4866   PyObject * obj1 = 0 ;
4867   char *  kwnames[] = {
4868     (char *) "self",(char *) "message", NULL
4869   };
4870
4871   if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Ldb_modify",kwnames,&obj0,&obj1)) SWIG_fail;
4872   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ldb_context, 0 |  0 );
4873   if (!SWIG_IsOK(res1)) {
4874     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Ldb_modify" "', argument " "1"" of type '" "ldb *""'");
4875   }
4876   arg1 = (ldb *)(argp1);
4877   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_ldb_message, 0 |  0 );
4878   if (!SWIG_IsOK(res2)) {
4879     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Ldb_modify" "', argument " "2"" of type '" "ldb_msg *""'");
4880   }
4881   arg2 = (ldb_msg *)(argp2);
4882   if (arg1 == NULL)
4883   SWIG_exception(SWIG_ValueError,
4884     "ldb context must be non-NULL");
4885   if (arg2 == NULL)
4886   SWIG_exception(SWIG_ValueError,
4887     "Message can not be None");
4888   result = ldb_modify(arg1,arg2);
4889   if (result != 0) {
4890     PyErr_SetObject(PyExc_LdbError, Py_BuildValue((char *)"(i,s)", result, ldb_errstring(arg1)));
4891     SWIG_fail;
4892   }
4893   resultobj = Py_None;
4894   return resultobj;
4895 fail:
4896   return NULL;
4897 }
4898
4899
4900 SWIGINTERN PyObject *_wrap_Ldb_get_config_basedn(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4901   PyObject *resultobj = 0;
4902   ldb *arg1 = (ldb *) 0 ;
4903   ldb_dn *result = 0 ;
4904   void *argp1 = 0 ;
4905   int res1 = 0 ;
4906   PyObject *swig_obj[1] ;
4907
4908   if (!args) SWIG_fail;
4909   swig_obj[0] = args;
4910   res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ldb_context, 0 |  0 );
4911   if (!SWIG_IsOK(res1)) {
4912     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Ldb_get_config_basedn" "', argument " "1"" of type '" "ldb *""'");
4913   }
4914   arg1 = (ldb *)(argp1);
4915   if (arg1 == NULL)
4916   SWIG_exception(SWIG_ValueError,
4917     "ldb context must be non-NULL");
4918   result = (ldb_dn *)ldb_get_config_basedn(arg1);
4919   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ldb_dn, 0 |  0 );
4920   return resultobj;
4921 fail:
4922   return NULL;
4923 }
4924
4925
4926 SWIGINTERN PyObject *_wrap_Ldb_get_root_basedn(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4927   PyObject *resultobj = 0;
4928   ldb *arg1 = (ldb *) 0 ;
4929   ldb_dn *result = 0 ;
4930   void *argp1 = 0 ;
4931   int res1 = 0 ;
4932   PyObject *swig_obj[1] ;
4933
4934   if (!args) SWIG_fail;
4935   swig_obj[0] = args;
4936   res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ldb_context, 0 |  0 );
4937   if (!SWIG_IsOK(res1)) {
4938     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Ldb_get_root_basedn" "', argument " "1"" of type '" "ldb *""'");
4939   }
4940   arg1 = (ldb *)(argp1);
4941   if (arg1 == NULL)
4942   SWIG_exception(SWIG_ValueError,
4943     "ldb context must be non-NULL");
4944   result = (ldb_dn *)ldb_get_root_basedn(arg1);
4945   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ldb_dn, 0 |  0 );
4946   return resultobj;
4947 fail:
4948   return NULL;
4949 }
4950
4951
4952 SWIGINTERN PyObject *_wrap_Ldb_get_schema_basedn(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4953   PyObject *resultobj = 0;
4954   ldb *arg1 = (ldb *) 0 ;
4955   ldb_dn *result = 0 ;
4956   void *argp1 = 0 ;
4957   int res1 = 0 ;
4958   PyObject *swig_obj[1] ;
4959
4960   if (!args) SWIG_fail;
4961   swig_obj[0] = args;
4962   res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ldb_context, 0 |  0 );
4963   if (!SWIG_IsOK(res1)) {
4964     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Ldb_get_schema_basedn" "', argument " "1"" of type '" "ldb *""'");
4965   }
4966   arg1 = (ldb *)(argp1);
4967   if (arg1 == NULL)
4968   SWIG_exception(SWIG_ValueError,
4969     "ldb context must be non-NULL");
4970   result = (ldb_dn *)ldb_get_schema_basedn(arg1);
4971   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ldb_dn, 0 |  0 );
4972   return resultobj;
4973 fail:
4974   return NULL;
4975 }
4976
4977
4978 SWIGINTERN PyObject *_wrap_Ldb_get_default_basedn(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4979   PyObject *resultobj = 0;
4980   ldb *arg1 = (ldb *) 0 ;
4981   ldb_dn *result = 0 ;
4982   void *argp1 = 0 ;
4983   int res1 = 0 ;
4984   PyObject *swig_obj[1] ;
4985
4986   if (!args) SWIG_fail;
4987   swig_obj[0] = args;
4988   res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ldb_context, 0 |  0 );
4989   if (!SWIG_IsOK(res1)) {
4990     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Ldb_get_default_basedn" "', argument " "1"" of type '" "ldb *""'");
4991   }
4992   arg1 = (ldb *)(argp1);
4993   if (arg1 == NULL)
4994   SWIG_exception(SWIG_ValueError,
4995     "ldb context must be non-NULL");
4996   result = (ldb_dn *)ldb_get_default_basedn(arg1);
4997   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ldb_dn, 0 |  0 );
4998   return resultobj;
4999 fail:
5000   return NULL;
5001 }
5002
5003
5004 SWIGINTERN PyObject *_wrap_Ldb_schema_format_value(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5005   PyObject *resultobj = 0;
5006   ldb *arg1 = (ldb *) 0 ;
5007   char *arg2 = (char *) 0 ;
5008   PyObject *arg3 = (PyObject *) 0 ;
5009   PyObject *result = 0 ;
5010   void *argp1 = 0 ;
5011   int res1 = 0 ;
5012   int res2 ;
5013   char *buf2 = 0 ;
5014   int alloc2 = 0 ;
5015   PyObject * obj0 = 0 ;
5016   PyObject * obj1 = 0 ;
5017   PyObject * obj2 = 0 ;
5018   char *  kwnames[] = {
5019     (char *) "self",(char *) "element_name",(char *) "val", NULL
5020   };
5021
5022   if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Ldb_schema_format_value",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
5023   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ldb_context, 0 |  0 );
5024   if (!SWIG_IsOK(res1)) {
5025     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Ldb_schema_format_value" "', argument " "1"" of type '" "ldb *""'");
5026   }
5027   arg1 = (ldb *)(argp1);
5028   res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
5029   if (!SWIG_IsOK(res2)) {
5030     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Ldb_schema_format_value" "', argument " "2"" of type '" "char const *""'");
5031   }
5032   arg2 = (char *)(buf2);
5033   arg3 = obj2;
5034   if (arg1 == NULL)
5035   SWIG_exception(SWIG_ValueError,
5036     "ldb context must be non-NULL");
5037   result = (PyObject *)ldb_schema_format_value(arg1,(char const *)arg2,arg3);
5038   resultobj = result;
5039   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
5040   return resultobj;
5041 fail:
5042   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
5043   return NULL;
5044 }
5045
5046
5047 SWIGINTERN PyObject *_wrap_Ldb_errstring(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5048   PyObject *resultobj = 0;
5049   ldb *arg1 = (ldb *) 0 ;
5050   char *result = 0 ;
5051   void *argp1 = 0 ;
5052   int res1 = 0 ;
5053   PyObject *swig_obj[1] ;
5054
5055   if (!args) SWIG_fail;
5056   swig_obj[0] = args;
5057   res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ldb_context, 0 |  0 );
5058   if (!SWIG_IsOK(res1)) {
5059     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Ldb_errstring" "', argument " "1"" of type '" "ldb *""'");
5060   }
5061   arg1 = (ldb *)(argp1);
5062   if (arg1 == NULL)
5063   SWIG_exception(SWIG_ValueError,
5064     "ldb context must be non-NULL");
5065   result = (char *)ldb_errstring(arg1);
5066   resultobj = SWIG_FromCharPtr((const char *)result);
5067   return resultobj;
5068 fail:
5069   return NULL;
5070 }
5071
5072
5073 SWIGINTERN PyObject *_wrap_Ldb_set_create_perms(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5074   PyObject *resultobj = 0;
5075   ldb *arg1 = (ldb *) 0 ;
5076   unsigned int arg2 ;
5077   void *argp1 = 0 ;
5078   int res1 = 0 ;
5079   unsigned int val2 ;
5080   int ecode2 = 0 ;
5081   PyObject * obj0 = 0 ;
5082   PyObject * obj1 = 0 ;
5083   char *  kwnames[] = {
5084     (char *) "self",(char *) "perms", NULL
5085   };
5086
5087   if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Ldb_set_create_perms",kwnames,&obj0,&obj1)) SWIG_fail;
5088   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ldb_context, 0 |  0 );
5089   if (!SWIG_IsOK(res1)) {
5090     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Ldb_set_create_perms" "', argument " "1"" of type '" "ldb *""'");
5091   }
5092   arg1 = (ldb *)(argp1);
5093   ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
5094   if (!SWIG_IsOK(ecode2)) {
5095     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Ldb_set_create_perms" "', argument " "2"" of type '" "unsigned int""'");
5096   }
5097   arg2 = (unsigned int)(val2);
5098   if (arg1 == NULL)
5099   SWIG_exception(SWIG_ValueError,
5100     "ldb context must be non-NULL");
5101   ldb_set_create_perms(arg1,arg2);
5102   resultobj = SWIG_Py_Void();
5103   return resultobj;
5104 fail:
5105   return NULL;
5106 }
5107
5108
5109 SWIGINTERN PyObject *_wrap_Ldb_set_modules_dir(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5110   PyObject *resultobj = 0;
5111   ldb *arg1 = (ldb *) 0 ;
5112   char *arg2 = (char *) 0 ;
5113   void *argp1 = 0 ;
5114   int res1 = 0 ;
5115   int res2 ;
5116   char *buf2 = 0 ;
5117   int alloc2 = 0 ;
5118   PyObject * obj0 = 0 ;
5119   PyObject * obj1 = 0 ;
5120   char *  kwnames[] = {
5121     (char *) "self",(char *) "path", NULL
5122   };
5123
5124   if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Ldb_set_modules_dir",kwnames,&obj0,&obj1)) SWIG_fail;
5125   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ldb_context, 0 |  0 );
5126   if (!SWIG_IsOK(res1)) {
5127     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Ldb_set_modules_dir" "', argument " "1"" of type '" "ldb *""'");
5128   }
5129   arg1 = (ldb *)(argp1);
5130   res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
5131   if (!SWIG_IsOK(res2)) {
5132     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Ldb_set_modules_dir" "', argument " "2"" of type '" "char const *""'");
5133   }
5134   arg2 = (char *)(buf2);
5135   if (arg1 == NULL)
5136   SWIG_exception(SWIG_ValueError,
5137     "ldb context must be non-NULL");
5138   ldb_set_modules_dir(arg1,(char const *)arg2);
5139   resultobj = SWIG_Py_Void();
5140   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
5141   return resultobj;
5142 fail:
5143   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
5144   return NULL;
5145 }
5146
5147
5148 SWIGINTERN PyObject *_wrap_Ldb_set_debug(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5149   PyObject *resultobj = 0;
5150   ldb *arg1 = (ldb *) 0 ;
5151   void (*arg2)(void *,enum ldb_debug_level,char const *,va_list) = (void (*)(void *,enum ldb_debug_level,char const *,va_list)) 0 ;
5152   void *arg3 = (void *) 0 ;
5153   ldb_error result;
5154   void *argp1 = 0 ;
5155   int res1 = 0 ;
5156   PyObject * obj0 = 0 ;
5157   PyObject * obj1 = 0 ;
5158   char *  kwnames[] = {
5159     (char *) "self",(char *) "debug", NULL
5160   };
5161
5162   if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Ldb_set_debug",kwnames,&obj0,&obj1)) SWIG_fail;
5163   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ldb_context, 0 |  0 );
5164   if (!SWIG_IsOK(res1)) {
5165     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Ldb_set_debug" "', argument " "1"" of type '" "ldb *""'");
5166   }
5167   arg1 = (ldb *)(argp1);
5168   arg2 = py_ldb_debug;
5169   /* FIXME: Should be decreased somewhere as well. Perhaps register a
5170          destructor and tie it to the ldb context ? */
5171   Py_INCREF(obj1);
5172   arg3 = obj1;
5173   if (arg1 == NULL)
5174   SWIG_exception(SWIG_ValueError,
5175     "ldb context must be non-NULL");
5176   result = ldb_set_debug(arg1,arg2,arg3);
5177   if (result != 0) {
5178     PyErr_SetObject(PyExc_LdbError, Py_BuildValue((char *)"(i,s)", result, ldb_errstring(arg1)));
5179     SWIG_fail;
5180   }
5181   resultobj = Py_None;
5182   return resultobj;
5183 fail:
5184   return NULL;
5185 }
5186
5187
5188 SWIGINTERN PyObject *_wrap_Ldb_set_opaque(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5189   PyObject *resultobj = 0;
5190   ldb *arg1 = (ldb *) 0 ;
5191   char *arg2 = (char *) 0 ;
5192   void *arg3 = (void *) 0 ;
5193   ldb_error result;
5194   void *argp1 = 0 ;
5195   int res1 = 0 ;
5196   int res2 ;
5197   char *buf2 = 0 ;
5198   int alloc2 = 0 ;
5199   int res3 ;
5200   PyObject * obj0 = 0 ;
5201   PyObject * obj1 = 0 ;
5202   PyObject * obj2 = 0 ;
5203   char *  kwnames[] = {
5204     (char *) "self",(char *) "name",(char *) "value", NULL
5205   };
5206
5207   if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Ldb_set_opaque",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
5208   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ldb_context, 0 |  0 );
5209   if (!SWIG_IsOK(res1)) {
5210     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Ldb_set_opaque" "', argument " "1"" of type '" "ldb *""'");
5211   }
5212   arg1 = (ldb *)(argp1);
5213   res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
5214   if (!SWIG_IsOK(res2)) {
5215     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Ldb_set_opaque" "', argument " "2"" of type '" "char const *""'");
5216   }
5217   arg2 = (char *)(buf2);
5218   res3 = SWIG_ConvertPtr(obj2,SWIG_as_voidptrptr(&arg3), 0, 0);
5219   if (!SWIG_IsOK(res3)) {
5220     SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Ldb_set_opaque" "', argument " "3"" of type '" "void *""'");
5221   }
5222   if (arg1 == NULL)
5223   SWIG_exception(SWIG_ValueError,
5224     "ldb context must be non-NULL");
5225   result = ldb_set_opaque(arg1,(char const *)arg2,arg3);
5226   if (result != 0) {
5227     PyErr_SetObject(PyExc_LdbError, Py_BuildValue((char *)"(i,s)", result, ldb_errstring(arg1)));
5228     SWIG_fail;
5229   }
5230   resultobj = Py_None;
5231   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
5232   return resultobj;
5233 fail:
5234   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
5235   return NULL;
5236 }
5237
5238
5239 SWIGINTERN PyObject *_wrap_Ldb_get_opaque(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5240   PyObject *resultobj = 0;
5241   ldb *arg1 = (ldb *) 0 ;
5242   char *arg2 = (char *) 0 ;
5243   void *result = 0 ;
5244   void *argp1 = 0 ;
5245   int res1 = 0 ;
5246   int res2 ;
5247   char *buf2 = 0 ;
5248   int alloc2 = 0 ;
5249   PyObject * obj0 = 0 ;
5250   PyObject * obj1 = 0 ;
5251   char *  kwnames[] = {
5252     (char *) "self",(char *) "name", NULL
5253   };
5254
5255   if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Ldb_get_opaque",kwnames,&obj0,&obj1)) SWIG_fail;
5256   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ldb_context, 0 |  0 );
5257   if (!SWIG_IsOK(res1)) {
5258     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Ldb_get_opaque" "', argument " "1"" of type '" "ldb *""'");
5259   }
5260   arg1 = (ldb *)(argp1);
5261   res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
5262   if (!SWIG_IsOK(res2)) {
5263     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Ldb_get_opaque" "', argument " "2"" of type '" "char const *""'");
5264   }
5265   arg2 = (char *)(buf2);
5266   if (arg1 == NULL)
5267   SWIG_exception(SWIG_ValueError,
5268     "ldb context must be non-NULL");
5269   result = (void *)ldb_get_opaque(arg1,(char const *)arg2);
5270   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 |  0 );
5271   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
5272   return resultobj;
5273 fail:
5274   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
5275   return NULL;
5276 }
5277
5278
5279 SWIGINTERN PyObject *_wrap_Ldb_transaction_start(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5280   PyObject *resultobj = 0;
5281   ldb *arg1 = (ldb *) 0 ;
5282   ldb_error result;
5283   void *argp1 = 0 ;
5284   int res1 = 0 ;
5285   PyObject *swig_obj[1] ;
5286
5287   if (!args) SWIG_fail;
5288   swig_obj[0] = args;
5289   res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ldb_context, 0 |  0 );
5290   if (!SWIG_IsOK(res1)) {
5291     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Ldb_transaction_start" "', argument " "1"" of type '" "ldb *""'");
5292   }
5293   arg1 = (ldb *)(argp1);
5294   if (arg1 == NULL)
5295   SWIG_exception(SWIG_ValueError,
5296     "ldb context must be non-NULL");
5297   result = ldb_transaction_start(arg1);
5298   if (result != 0) {
5299     PyErr_SetObject(PyExc_LdbError, Py_BuildValue((char *)"(i,s)", result, ldb_errstring(arg1)));
5300     SWIG_fail;
5301   }
5302   resultobj = Py_None;
5303   return resultobj;
5304 fail:
5305   return NULL;
5306 }
5307
5308
5309 SWIGINTERN PyObject *_wrap_Ldb_transaction_commit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5310   PyObject *resultobj = 0;
5311   ldb *arg1 = (ldb *) 0 ;
5312   ldb_error result;
5313   void *argp1 = 0 ;
5314   int res1 = 0 ;
5315   PyObject *swig_obj[1] ;
5316
5317   if (!args) SWIG_fail;
5318   swig_obj[0] = args;
5319   res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ldb_context, 0 |  0 );
5320   if (!SWIG_IsOK(res1)) {
5321     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Ldb_transaction_commit" "', argument " "1"" of type '" "ldb *""'");
5322   }
5323   arg1 = (ldb *)(argp1);
5324   if (arg1 == NULL)
5325   SWIG_exception(SWIG_ValueError,
5326     "ldb context must be non-NULL");
5327   result = ldb_transaction_commit(arg1);
5328   if (result != 0) {
5329     PyErr_SetObject(PyExc_LdbError, Py_BuildValue((char *)"(i,s)", result, ldb_errstring(arg1)));
5330     SWIG_fail;
5331   }
5332   resultobj = Py_None;
5333   return resultobj;
5334 fail:
5335   return NULL;
5336 }
5337
5338
5339 SWIGINTERN PyObject *_wrap_Ldb_transaction_cancel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5340   PyObject *resultobj = 0;
5341   ldb *arg1 = (ldb *) 0 ;
5342   ldb_error result;
5343   void *argp1 = 0 ;
5344   int res1 = 0 ;
5345   PyObject *swig_obj[1] ;
5346
5347   if (!args) SWIG_fail;
5348   swig_obj[0] = args;
5349   res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ldb_context, 0 |  0 );
5350   if (!SWIG_IsOK(res1)) {
5351     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Ldb_transaction_cancel" "', argument " "1"" of type '" "ldb *""'");
5352   }
5353   arg1 = (ldb *)(argp1);
5354   if (arg1 == NULL)
5355   SWIG_exception(SWIG_ValueError,
5356     "ldb context must be non-NULL");
5357   result = ldb_transaction_cancel(arg1);
5358   if (result != 0) {
5359     PyErr_SetObject(PyExc_LdbError, Py_BuildValue((char *)"(i,s)", result, ldb_errstring(arg1)));
5360     SWIG_fail;
5361   }
5362   resultobj = Py_None;
5363   return resultobj;
5364 fail:
5365   return NULL;
5366 }
5367
5368
5369 SWIGINTERN PyObject *_wrap_Ldb_schema_attribute_remove(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5370   PyObject *resultobj = 0;
5371   ldb *arg1 = (ldb *) 0 ;
5372   char *arg2 = (char *) 0 ;
5373   void *argp1 = 0 ;
5374   int res1 = 0 ;
5375   int res2 ;
5376   char *buf2 = 0 ;
5377   int alloc2 = 0 ;
5378   PyObject * obj0 = 0 ;
5379   PyObject * obj1 = 0 ;
5380   char *  kwnames[] = {
5381     (char *) "self",(char *) "name", NULL
5382   };
5383
5384   if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Ldb_schema_attribute_remove",kwnames,&obj0,&obj1)) SWIG_fail;
5385   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ldb_context, 0 |  0 );
5386   if (!SWIG_IsOK(res1)) {
5387     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Ldb_schema_attribute_remove" "', argument " "1"" of type '" "ldb *""'");
5388   }
5389   arg1 = (ldb *)(argp1);
5390   res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
5391   if (!SWIG_IsOK(res2)) {
5392     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Ldb_schema_attribute_remove" "', argument " "2"" of type '" "char const *""'");
5393   }
5394   arg2 = (char *)(buf2);
5395   if (arg1 == NULL)
5396   SWIG_exception(SWIG_ValueError,
5397     "ldb context must be non-NULL");
5398   ldb_schema_attribute_remove(arg1,(char const *)arg2);
5399   resultobj = SWIG_Py_Void();
5400   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
5401   return resultobj;
5402 fail:
5403   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
5404   return NULL;
5405 }
5406
5407
5408 SWIGINTERN PyObject *_wrap_Ldb_schema_attribute_add(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5409   PyObject *resultobj = 0;
5410   ldb *arg1 = (ldb *) 0 ;
5411   char *arg2 = (char *) 0 ;
5412   unsigned int arg3 ;
5413   char *arg4 = (char *) 0 ;
5414   ldb_error result;
5415   void *argp1 = 0 ;
5416   int res1 = 0 ;
5417   int res2 ;
5418   char *buf2 = 0 ;
5419   int alloc2 = 0 ;
5420   unsigned int val3 ;
5421   int ecode3 = 0 ;
5422   int res4 ;
5423   char *buf4 = 0 ;
5424   int alloc4 = 0 ;
5425   PyObject * obj0 = 0 ;
5426   PyObject * obj1 = 0 ;
5427   PyObject * obj2 = 0 ;
5428   PyObject * obj3 = 0 ;
5429   char *  kwnames[] = {
5430     (char *) "self",(char *) "attribute",(char *) "flags",(char *) "syntax", NULL
5431   };
5432
5433   if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Ldb_schema_attribute_add",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
5434   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ldb_context, 0 |  0 );
5435   if (!SWIG_IsOK(res1)) {
5436     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Ldb_schema_attribute_add" "', argument " "1"" of type '" "ldb *""'");
5437   }
5438   arg1 = (ldb *)(argp1);
5439   res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
5440   if (!SWIG_IsOK(res2)) {
5441     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Ldb_schema_attribute_add" "', argument " "2"" of type '" "char const *""'");
5442   }
5443   arg2 = (char *)(buf2);
5444   ecode3 = SWIG_AsVal_unsigned_SS_int(obj2, &val3);
5445   if (!SWIG_IsOK(ecode3)) {
5446     SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Ldb_schema_attribute_add" "', argument " "3"" of type '" "unsigned int""'");
5447   }
5448   arg3 = (unsigned int)(val3);
5449   res4 = SWIG_AsCharPtrAndSize(obj3, &buf4, NULL, &alloc4);
5450   if (!SWIG_IsOK(res4)) {
5451     SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Ldb_schema_attribute_add" "', argument " "4"" of type '" "char const *""'");
5452   }
5453   arg4 = (char *)(buf4);
5454   if (arg1 == NULL)
5455   SWIG_exception(SWIG_ValueError,
5456     "ldb context must be non-NULL");
5457   result = ldb_schema_attribute_add(arg1,(char const *)arg2,arg3,(char const *)arg4);
5458   if (result != 0) {
5459     PyErr_SetObject(PyExc_LdbError, Py_BuildValue((char *)"(i,s)", result, ldb_errstring(arg1)));
5460     SWIG_fail;
5461   }
5462   resultobj = Py_None;
5463   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
5464   if (alloc4 == SWIG_NEWOBJ) free((char*)buf4);
5465   return resultobj;
5466 fail:
5467   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
5468   if (alloc4 == SWIG_NEWOBJ) free((char*)buf4);
5469   return NULL;
5470 }
5471
5472
5473 SWIGINTERN PyObject *_wrap_Ldb_setup_wellknown_attributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5474   PyObject *resultobj = 0;
5475   ldb *arg1 = (ldb *) 0 ;
5476   ldb_error result;
5477   void *argp1 = 0 ;
5478   int res1 = 0 ;
5479   PyObject *swig_obj[1] ;
5480
5481   if (!args) SWIG_fail;
5482   swig_obj[0] = args;
5483   res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ldb_context, 0 |  0 );
5484   if (!SWIG_IsOK(res1)) {
5485     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Ldb_setup_wellknown_attributes" "', argument " "1"" of type '" "ldb *""'");
5486   }
5487   arg1 = (ldb *)(argp1);
5488   if (arg1 == NULL)
5489   SWIG_exception(SWIG_ValueError,
5490     "ldb context must be non-NULL");
5491   result = ldb_setup_wellknown_attributes(arg1);
5492   if (result != 0) {
5493     PyErr_SetObject(PyExc_LdbError, Py_BuildValue((char *)"(i,s)", result, ldb_errstring(arg1)));
5494     SWIG_fail;
5495   }
5496   resultobj = Py_None;
5497   return resultobj;
5498 fail:
5499   return NULL;
5500 }
5501
5502
5503 SWIGINTERN PyObject *_wrap_Ldb___contains__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5504   PyObject *resultobj = 0;
5505   ldb *arg1 = (ldb *) 0 ;
5506   ldb_dn *arg2 = (ldb_dn *) 0 ;
5507   struct ldb_result **arg3 = (struct ldb_result **) 0 ;
5508   ldb_error result;
5509   void *argp1 = 0 ;
5510   int res1 = 0 ;
5511   struct ldb_result *tmp3 ;
5512   PyObject * obj0 = 0 ;
5513   PyObject * obj1 = 0 ;
5514   char *  kwnames[] = {
5515     (char *) "self",(char *) "dn", NULL
5516   };
5517
5518   arg3 = &tmp3;
5519   if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Ldb___contains__",kwnames,&obj0,&obj1)) SWIG_fail;
5520   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ldb_context, 0 |  0 );
5521   if (!SWIG_IsOK(res1)) {
5522     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Ldb___contains__" "', argument " "1"" of type '" "ldb *""'");
5523   }
5524   arg1 = (ldb *)(argp1);
5525   if (ldb_dn_from_pyobject(NULL, obj1, arg1, &arg2) != 0) {
5526     SWIG_fail;
5527   }
5528   if (arg1 == NULL)
5529   SWIG_exception(SWIG_ValueError,
5530     "ldb context must be non-NULL");
5531   result = ldb___contains__(arg1,arg2,arg3);
5532   if (result != 0) {
5533     PyErr_SetObject(PyExc_LdbError, Py_BuildValue((char *)"(i,s)", result, ldb_errstring(arg1)));
5534     SWIG_fail;
5535   }
5536   resultobj = Py_None;
5537   resultobj = ((*arg3)->count > 0)?Py_True:Py_False;
5538   talloc_free(arg2);
5539   talloc_free(*arg3);
5540   return resultobj;
5541 fail:
5542   talloc_free(arg2);
5543   talloc_free(*arg3);
5544   return NULL;
5545 }
5546
5547
5548 SWIGINTERN PyObject *_wrap_Ldb_parse_ldif(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5549   PyObject *resultobj = 0;
5550   ldb *arg1 = (ldb *) 0 ;
5551   char *arg2 = (char *) 0 ;
5552   PyObject *result = 0 ;
5553   void *argp1 = 0 ;
5554   int res1 = 0 ;
5555   int res2 ;
5556   char *buf2 = 0 ;
5557   int alloc2 = 0 ;
5558   PyObject * obj0 = 0 ;
5559   PyObject * obj1 = 0 ;
5560   char *  kwnames[] = {
5561     (char *) "self",(char *) "s", NULL
5562   };
5563
5564   if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Ldb_parse_ldif",kwnames,&obj0,&obj1)) SWIG_fail;
5565   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ldb_context, 0 |  0 );
5566   if (!SWIG_IsOK(res1)) {
5567     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Ldb_parse_ldif" "', argument " "1"" of type '" "ldb *""'");
5568   }
5569   arg1 = (ldb *)(argp1);
5570   res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
5571   if (!SWIG_IsOK(res2)) {
5572     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Ldb_parse_ldif" "', argument " "2"" of type '" "char const *""'");
5573   }
5574   arg2 = (char *)(buf2);
5575   if (arg1 == NULL)
5576   SWIG_exception(SWIG_ValueError,
5577     "ldb context must be non-NULL");
5578   result = (PyObject *)ldb_parse_ldif(arg1,(char const *)arg2);
5579   resultobj = result;
5580   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
5581   return resultobj;
5582 fail:
5583   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
5584   return NULL;
5585 }
5586
5587
5588 SWIGINTERN PyObject *_wrap_Ldb___repr__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5589   PyObject *resultobj = 0;
5590   ldb *arg1 = (ldb *) 0 ;
5591   char *result = 0 ;
5592   void *argp1 = 0 ;
5593   int res1 = 0 ;
5594   PyObject *swig_obj[1] ;
5595
5596   if (!args) SWIG_fail;
5597   swig_obj[0] = args;
5598   res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ldb_context, 0 |  0 );
5599   if (!SWIG_IsOK(res1)) {
5600     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Ldb___repr__" "', argument " "1"" of type '" "ldb *""'");
5601   }
5602   arg1 = (ldb *)(argp1);
5603   if (arg1 == NULL)
5604   SWIG_exception(SWIG_ValueError,
5605     "ldb context must be non-NULL");
5606   result = (char *)ldb___repr__(arg1);
5607   resultobj = SWIG_FromCharPtr((const char *)result);
5608   return resultobj;
5609 fail:
5610   return NULL;
5611 }
5612
5613
5614 SWIGINTERN PyObject *Ldb_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5615   PyObject *obj;
5616   if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
5617   SWIG_TypeNewClientData(SWIGTYPE_p_ldb_context, SWIG_NewClientData(obj));
5618   return SWIG_Py_Void();
5619 }
5620
5621 SWIGINTERN PyObject *Ldb_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5622   return SWIG_Python_InitShadowInstance(args);
5623 }
5624
5625 SWIGINTERN PyObject *_wrap_valid_attr_name(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5626   PyObject *resultobj = 0;
5627   char *arg1 = (char *) 0 ;
5628   int result;
5629   int res1 ;
5630   char *buf1 = 0 ;
5631   int alloc1 = 0 ;
5632   PyObject * obj0 = 0 ;
5633   char *  kwnames[] = {
5634     (char *) "s", NULL
5635   };
5636
5637   if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:valid_attr_name",kwnames,&obj0)) SWIG_fail;
5638   res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
5639   if (!SWIG_IsOK(res1)) {
5640     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "valid_attr_name" "', argument " "1"" of type '" "char const *""'");
5641   }
5642   arg1 = (char *)(buf1);
5643   result = (int)ldb_valid_attr_name((char const *)arg1);
5644   resultobj = SWIG_From_int((int)(result));
5645   if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
5646   return resultobj;
5647 fail:
5648   if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
5649   return NULL;
5650 }
5651
5652
5653 SWIGINTERN PyObject *_wrap_timestring(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5654   PyObject *resultobj = 0;
5655   time_t arg1 ;
5656   char *result = 0 ;
5657   unsigned long val1 ;
5658   int ecode1 = 0 ;
5659   PyObject * obj0 = 0 ;
5660   char *  kwnames[] = {
5661     (char *) "t", NULL
5662   };
5663
5664   if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:timestring",kwnames,&obj0)) SWIG_fail;
5665   ecode1 = SWIG_AsVal_unsigned_SS_long(obj0, &val1);
5666   if (!SWIG_IsOK(ecode1)) {
5667     SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "timestring" "', argument " "1"" of type '" "time_t""'");
5668   }
5669   arg1 = (time_t)(val1);
5670   result = (char *)timestring(arg1);
5671   resultobj = SWIG_FromCharPtr((const char *)result);
5672   return resultobj;
5673 fail:
5674   return NULL;
5675 }
5676
5677
5678 SWIGINTERN PyObject *_wrap_string_to_time(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5679   PyObject *resultobj = 0;
5680   char *arg1 = (char *) 0 ;
5681   time_t result;
5682   int res1 ;
5683   char *buf1 = 0 ;
5684   int alloc1 = 0 ;
5685   PyObject * obj0 = 0 ;
5686   char *  kwnames[] = {
5687     (char *) "s", NULL
5688   };
5689
5690   if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:string_to_time",kwnames,&obj0)) SWIG_fail;
5691   res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
5692   if (!SWIG_IsOK(res1)) {
5693     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "string_to_time" "', argument " "1"" of type '" "char const *""'");
5694   }
5695   arg1 = (char *)(buf1);
5696   result = (time_t)ldb_string_to_time((char const *)arg1);
5697   resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
5698   if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
5699   return resultobj;
5700 fail:
5701   if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
5702   return NULL;
5703 }
5704
5705
5706 SWIGINTERN PyObject *_wrap_register_module(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5707   PyObject *resultobj = 0;
5708   struct ldb_module_ops *arg1 = (struct ldb_module_ops *) 0 ;
5709   ldb_int_error result;
5710   PyObject * obj0 = 0 ;
5711   char *  kwnames[] = {
5712     (char *)"arg1", NULL
5713   };
5714
5715   if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:register_module",kwnames,&obj0)) SWIG_fail;
5716   arg1 = talloc_zero(talloc_autofree_context(), struct ldb_module_ops);
5717
5718   arg1->name = (char *)PyObject_GetAttrString(obj0, (char *)"name");
5719   result = ldb_register_module((struct ldb_module_ops const *)arg1);
5720   if (result != 0) {
5721     PyErr_SetObject(PyExc_LdbError, Py_BuildValue((char *)"(i,s)", result, ldb_strerror(result)));
5722     SWIG_fail;
5723   }
5724   resultobj = Py_None;
5725   return resultobj;
5726 fail:
5727   return NULL;
5728 }
5729
5730
5731 static PyMethodDef SwigMethods[] = {
5732          { (char *)"ldb_val_to_py_object", (PyCFunction) _wrap_ldb_val_to_py_object, METH_VARARGS | METH_KEYWORDS, NULL},
5733          { (char *)"new_Dn", (PyCFunction) _wrap_new_Dn, METH_VARARGS | METH_KEYWORDS, (char *)"\n"
5734                 "S.__init__(ldb, string)\n"
5735                 "Create a new DN.\n"
5736                 ""},
5737          { (char *)"delete_Dn", (PyCFunction)_wrap_delete_Dn, METH_O, NULL},
5738          { (char *)"Dn_validate", (PyCFunction)_wrap_Dn_validate, METH_O, (char *)"\n"
5739                 "S.validate() -> bool\n"
5740                 "Validate DN is correct.\n"
5741                 ""},
5742          { (char *)"Dn_get_casefold", (PyCFunction)_wrap_Dn_get_casefold, METH_O, NULL},
5743          { (char *)"Dn___str__", (PyCFunction)_wrap_Dn___str__, METH_O, NULL},
5744          { (char *)"Dn_parent", (PyCFunction)_wrap_Dn_parent, METH_O, (char *)"\n"
5745                 "S.parent() -> dn\n"
5746                 "Get the parent for this DN.\n"
5747                 ""},
5748          { (char *)"Dn___cmp__", (PyCFunction) _wrap_Dn___cmp__, METH_VARARGS | METH_KEYWORDS, NULL},
5749          { (char *)"Dn_is_valid", (PyCFunction)_wrap_Dn_is_valid, METH_O, NULL},
5750          { (char *)"Dn_is_special", (PyCFunction)_wrap_Dn_is_special, METH_O, (char *)"\n"
5751                 "S.is_special() -> bool\n"
5752                 "Check whether this is a special LDB DN.\n"
5753                 ""},
5754          { (char *)"Dn_is_null", (PyCFunction)_wrap_Dn_is_null, METH_O, (char *)"\n"
5755                 "S.is_null() -> bool\n"
5756                 "Check whether this is a null DN.\n"
5757                 ""},
5758          { (char *)"Dn_check_special", (PyCFunction) _wrap_Dn_check_special, METH_VARARGS | METH_KEYWORDS, NULL},
5759          { (char *)"Dn___len__", (PyCFunction)_wrap_Dn___len__, METH_O, NULL},
5760          { (char *)"Dn_add_child", (PyCFunction) _wrap_Dn_add_child, METH_VARARGS | METH_KEYWORDS, (char *)"\n"
5761                 "S.add_child(dn) -> None\n"
5762                 "Add a child DN to this DN.\n"
5763                 ""},
5764          { (char *)"Dn_add_base", (PyCFunction) _wrap_Dn_add_base, METH_VARARGS | METH_KEYWORDS, (char *)"\n"
5765                 "S.add_base(dn) -> None\n"
5766                 "Add a base DN to this DN.\n"
5767                 ""},
5768          { (char *)"Dn_canonical_str", (PyCFunction)_wrap_Dn_canonical_str, METH_O, (char *)"\n"
5769                 "S.canonical_str() -> string\n"
5770                 "Canonical version of this DN (like a posix path).\n"
5771                 ""},
5772          { (char *)"Dn_canonical_ex_str", (PyCFunction)_wrap_Dn_canonical_ex_str, METH_O, (char *)"\n"
5773                 "S.canonical_ex_str() -> string\n"
5774                 "Canonical version of this DN (like a posix path, with terminating newline).\n"
5775                 ""},
5776          { (char *)"Dn___repr__", (PyCFunction)_wrap_Dn___repr__, METH_O, NULL},
5777          { (char *)"Dn___add__", (PyCFunction) _wrap_Dn___add__, METH_VARARGS | METH_KEYWORDS, NULL},
5778          { (char *)"Dn_swigregister", Dn_swigregister, METH_VARARGS, NULL},
5779          { (char *)"Dn_swiginit", Dn_swiginit, METH_VARARGS, NULL},
5780          { (char *)"MessageElement___cmp__", (PyCFunction) _wrap_MessageElement___cmp__, METH_VARARGS | METH_KEYWORDS, NULL},
5781          { (char *)"MessageElement___iter__", (PyCFunction)_wrap_MessageElement___iter__, METH_O, NULL},
5782          { (char *)"MessageElement___set__", (PyCFunction)_wrap_MessageElement___set__, METH_O, NULL},
5783          { (char *)"new_MessageElement", (PyCFunction) _wrap_new_MessageElement, METH_VARARGS | METH_KEYWORDS, (char *)"Message element."},
5784          { (char *)"MessageElement___len__", (PyCFunction)_wrap_MessageElement___len__, METH_O, NULL},
5785          { (char *)"MessageElement_get", (PyCFunction) _wrap_MessageElement_get, METH_VARARGS | METH_KEYWORDS, NULL},
5786          { (char *)"delete_MessageElement", (PyCFunction)_wrap_delete_MessageElement, METH_O, NULL},
5787          { (char *)"MessageElement_swigregister", MessageElement_swigregister, METH_VARARGS, NULL},
5788          { (char *)"MessageElement_swiginit", MessageElement_swiginit, METH_VARARGS, NULL},
5789          { (char *)"ldb_msg_list_elements", (PyCFunction) _wrap_ldb_msg_list_elements, METH_VARARGS | METH_KEYWORDS, NULL},
5790          { (char *)"Message_dn_set", _wrap_Message_dn_set, METH_VARARGS, NULL},
5791          { (char *)"Message_dn_get", (PyCFunction)_wrap_Message_dn_get, METH_O, NULL},
5792          { (char *)"new_Message", (PyCFunction) _wrap_new_Message, METH_VARARGS | METH_KEYWORDS, NULL},
5793          { (char *)"delete_Message", (PyCFunction)_wrap_delete_Message, METH_O, NULL},
5794          { (char *)"Message_find_element", (PyCFunction) _wrap_Message_find_element, METH_VARARGS | METH_KEYWORDS, NULL},
5795          { (char *)"Message___setitem__", _wrap_Message___setitem__, METH_VARARGS, NULL},
5796          { (char *)"Message___len__", (PyCFunction)_wrap_Message___len__, METH_O, NULL},
5797          { (char *)"Message_keys", (PyCFunction)_wrap_Message_keys, METH_O, NULL},
5798          { (char *)"Message___iter__", (PyCFunction)_wrap_Message___iter__, METH_O, NULL},
5799          { (char *)"Message___delitem__", (PyCFunction) _wrap_Message___delitem__, METH_VARARGS | METH_KEYWORDS, NULL},
5800          { (char *)"Message_swigregister", Message_swigregister, METH_VARARGS, NULL},
5801          { (char *)"Message_swiginit", Message_swiginit, METH_VARARGS, NULL},
5802          { (char *)"ldb_ldif_to_pyobject", (PyCFunction) _wrap_ldb_ldif_to_pyobject, METH_VARARGS | METH_KEYWORDS, NULL},
5803          { (char *)"new_Ldb", (PyCFunction)_wrap_new_Ldb, METH_NOARGS, NULL},
5804          { (char *)"Ldb_connect", (PyCFunction) _wrap_Ldb_connect, METH_VARARGS | METH_KEYWORDS, (char *)"\n"
5805                 "S.connect(url,flags=0,options=None) -> None\n"
5806                 "Connect to a LDB URL.\n"
5807                 ""},
5808          { (char *)"delete_Ldb", (PyCFunction)_wrap_delete_Ldb, METH_O, NULL},
5809          { (char *)"Ldb_search_ex", (PyCFunction) _wrap_Ldb_search_ex, METH_VARARGS | METH_KEYWORDS, NULL},
5810          { (char *)"Ldb_delete", (PyCFunction) _wrap_Ldb_delete, METH_VARARGS | METH_KEYWORDS, (char *)"\n"
5811                 "S.delete(dn) -> None\n"
5812                 "Remove an entry.\n"
5813                 ""},
5814          { (char *)"Ldb_rename", (PyCFunction) _wrap_Ldb_rename, METH_VARARGS | METH_KEYWORDS, (char *)"\n"
5815                 "S.rename(old_dn, new_dn) -> None\n"
5816                 "Rename an entry.\n"
5817                 ""},
5818          { (char *)"Ldb_parse_control_strings", (PyCFunction) _wrap_Ldb_parse_control_strings, METH_VARARGS | METH_KEYWORDS, NULL},
5819          { (char *)"Ldb_add", (PyCFunction) _wrap_Ldb_add, METH_VARARGS | METH_KEYWORDS, (char *)"\n"
5820                 "S.add(message) -> None\n"
5821                 "Add an entry.\n"
5822                 ""},
5823          { (char *)"Ldb_modify", (PyCFunction) _wrap_Ldb_modify, METH_VARARGS | METH_KEYWORDS, (char *)"\n"
5824                 "S.modify(message) -> None\n"
5825                 "Modify an entry.\n"
5826                 ""},
5827          { (char *)"Ldb_get_config_basedn", (PyCFunction)_wrap_Ldb_get_config_basedn, METH_O, NULL},
5828          { (char *)"Ldb_get_root_basedn", (PyCFunction)_wrap_Ldb_get_root_basedn, METH_O, NULL},
5829          { (char *)"Ldb_get_schema_basedn", (PyCFunction)_wrap_Ldb_get_schema_basedn, METH_O, NULL},
5830          { (char *)"Ldb_get_default_basedn", (PyCFunction)_wrap_Ldb_get_default_basedn, METH_O, NULL},
5831          { (char *)"Ldb_schema_format_value", (PyCFunction) _wrap_Ldb_schema_format_value, METH_VARARGS | METH_KEYWORDS, NULL},
5832          { (char *)"Ldb_errstring", (PyCFunction)_wrap_Ldb_errstring, METH_O, NULL},
5833          { (char *)"Ldb_set_create_perms", (PyCFunction) _wrap_Ldb_set_create_perms, METH_VARARGS | METH_KEYWORDS, (char *)"\n"
5834                 "S.set_create_perms(mode) -> None\n"
5835                 "Set mode to use when creating new LDB files.\n"
5836                 ""},
5837          { (char *)"Ldb_set_modules_dir", (PyCFunction) _wrap_Ldb_set_modules_dir, METH_VARARGS | METH_KEYWORDS, (char *)"\n"
5838                 "S.set_modules_dir(path) -> None\n"
5839                 "Set path LDB should search for modules\n"
5840                 ""},
5841          { (char *)"Ldb_set_debug", (PyCFunction) _wrap_Ldb_set_debug, METH_VARARGS | METH_KEYWORDS, (char *)"\n"
5842                 "S.set_debug(callback) -> None\n"
5843                 "Set callback for LDB debug messages.\n"
5844                 "The callback should accept a debug level and debug text.\n"
5845                 ""},
5846          { (char *)"Ldb_set_opaque", (PyCFunction) _wrap_Ldb_set_opaque, METH_VARARGS | METH_KEYWORDS, (char *)"\n"
5847                 "S.set_opaque(name, value) -> None\n"
5848                 "Set an opaque value on this LDB connection. \n"
5849                 ":note: Passing incorrect values may cause crashes.\n"
5850                 ""},
5851          { (char *)"Ldb_get_opaque", (PyCFunction) _wrap_Ldb_get_opaque, METH_VARARGS | METH_KEYWORDS, (char *)"\n"
5852                 "S.get_opaque(name) -> value\n"
5853                 "Get an opaque value set on this LDB connection. \n"
5854                 ":note: The returned value may not be useful in Python.\n"
5855                 ""},
5856          { (char *)"Ldb_transaction_start", (PyCFunction)_wrap_Ldb_transaction_start, METH_O, (char *)"\n"
5857                 "S.transaction_start() -> None\n"
5858                 "Start a new transaction.\n"
5859                 ""},
5860          { (char *)"Ldb_transaction_commit", (PyCFunction)_wrap_Ldb_transaction_commit, METH_O, (char *)"\n"
5861                 "S.transaction_commit() -> None\n"
5862                 "Commit currently active transaction.\n"
5863                 ""},
5864          { (char *)"Ldb_transaction_cancel", (PyCFunction)_wrap_Ldb_transaction_cancel, METH_O, (char *)"\n"
5865                 "S.transaction_cancel() -> None\n"
5866                 "Cancel currently active transaction.\n"
5867                 ""},
5868          { (char *)"Ldb_schema_attribute_remove", (PyCFunction) _wrap_Ldb_schema_attribute_remove, METH_VARARGS | METH_KEYWORDS, NULL},
5869          { (char *)"Ldb_schema_attribute_add", (PyCFunction) _wrap_Ldb_schema_attribute_add, METH_VARARGS | METH_KEYWORDS, NULL},
5870          { (char *)"Ldb_setup_wellknown_attributes", (PyCFunction)_wrap_Ldb_setup_wellknown_attributes, METH_O, NULL},
5871          { (char *)"Ldb___contains__", (PyCFunction) _wrap_Ldb___contains__, METH_VARARGS | METH_KEYWORDS, NULL},
5872          { (char *)"Ldb_parse_ldif", (PyCFunction) _wrap_Ldb_parse_ldif, METH_VARARGS | METH_KEYWORDS, (char *)"\n"
5873                 "S.parse_ldif(ldif) -> iter(messages)\n"
5874                 "Parse a string formatted using LDIF.\n"
5875                 ""},
5876          { (char *)"Ldb___repr__", (PyCFunction)_wrap_Ldb___repr__, METH_O, NULL},
5877          { (char *)"Ldb_swigregister", Ldb_swigregister, METH_VARARGS, NULL},
5878          { (char *)"Ldb_swiginit", Ldb_swiginit, METH_VARARGS, NULL},
5879          { (char *)"valid_attr_name", (PyCFunction) _wrap_valid_attr_name, METH_VARARGS | METH_KEYWORDS, (char *)"\n"
5880                 "S.valid_attr_name(name) -> bool\n"
5881                 "Check whether the supplied name is a valid attribute name.\n"
5882                 ""},
5883          { (char *)"timestring", (PyCFunction) _wrap_timestring, METH_VARARGS | METH_KEYWORDS, (char *)"\n"
5884                 "S.timestring(int) -> string\n"
5885                 "Generate a LDAP time string from a UNIX timestamp\n"
5886                 ""},
5887          { (char *)"string_to_time", (PyCFunction) _wrap_string_to_time, METH_VARARGS | METH_KEYWORDS, (char *)"\n"
5888                 "S.string_to_time(string) -> int\n"
5889                 "Parse a LDAP time string into a UNIX timestamp.\n"
5890                 ""},
5891          { (char *)"register_module", (PyCFunction) _wrap_register_module, METH_VARARGS | METH_KEYWORDS, (char *)"\n"
5892                 "S.register_module(module) -> None\n"
5893                 "Register a LDB module.\n"
5894                 ""},
5895          { NULL, NULL, 0, NULL }
5896 };
5897
5898
5899 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
5900
5901 static swig_type_info _swigt__p_TALLOC_CTX = {"_p_TALLOC_CTX", "TALLOC_CTX *", 0, 0, (void*)0, 0};
5902 static swig_type_info _swigt__p_char = {"_p_char", "char *", 0, 0, (void*)0, 0};
5903 static swig_type_info _swigt__p_f_p_void_enum_ldb_debug_level_p_q_const__char_va_list__void = {"_p_f_p_void_enum_ldb_debug_level_p_q_const__char_va_list__void", "void (*)(void *,enum ldb_debug_level,char const *,va_list)", 0, 0, (void*)0, 0};
5904 static swig_type_info _swigt__p_int = {"_p_int", "intptr_t *|int *|int_least32_t *|int_fast32_t *|int32_t *|int_fast16_t *", 0, 0, (void*)0, 0};
5905 static swig_type_info _swigt__p_ldb_context = {"_p_ldb_context", "struct ldb_context *|ldb *", 0, 0, (void*)0, 0};
5906 static swig_type_info _swigt__p_ldb_dn = {"_p_ldb_dn", "struct ldb_dn *|ldb_dn *", 0, 0, (void*)0, 0};
5907 static swig_type_info _swigt__p_ldb_ldif = {"_p_ldb_ldif", "struct ldb_ldif *|ldb_ldif *", 0, 0, (void*)0, 0};
5908 static swig_type_info _swigt__p_ldb_message = {"_p_ldb_message", "ldb_msg *|struct ldb_message *", 0, 0, (void*)0, 0};
5909 static swig_type_info _swigt__p_ldb_message_element = {"_p_ldb_message_element", "struct ldb_message_element *|ldb_message_element *", 0, 0, (void*)0, 0};
5910 static swig_type_info _swigt__p_ldb_module_ops = {"_p_ldb_module_ops", "struct ldb_module_ops *", 0, 0, (void*)0, 0};
5911 static swig_type_info _swigt__p_ldb_result = {"_p_ldb_result", "struct ldb_result *", 0, 0, (void*)0, 0};
5912 static swig_type_info _swigt__p_ldb_val = {"_p_ldb_val", "struct ldb_val *", 0, 0, (void*)0, 0};
5913 static swig_type_info _swigt__p_long_long = {"_p_long_long", "int_least64_t *|int_fast64_t *|int64_t *|long long *|intmax_t *", 0, 0, (void*)0, 0};
5914 static swig_type_info _swigt__p_p_char = {"_p_p_char", "char **", 0, 0, (void*)0, 0};
5915 static swig_type_info _swigt__p_p_ldb_control = {"_p_p_ldb_control", "struct ldb_control **", 0, 0, (void*)0, 0};
5916 static swig_type_info _swigt__p_p_ldb_result = {"_p_p_ldb_result", "struct ldb_result **", 0, 0, (void*)0, 0};
5917 static swig_type_info _swigt__p_short = {"_p_short", "short *|int_least16_t *|int16_t *", 0, 0, (void*)0, 0};
5918 static swig_type_info _swigt__p_signed_char = {"_p_signed_char", "signed char *|int_least8_t *|int_fast8_t *|int8_t *", 0, 0, (void*)0, 0};
5919 static swig_type_info _swigt__p_unsigned_char = {"_p_unsigned_char", "unsigned char *|uint_least8_t *|uint_fast8_t *|uint8_t *", 0, 0, (void*)0, 0};
5920 static swig_type_info _swigt__p_unsigned_int = {"_p_unsigned_int", "uintptr_t *|uint_least32_t *|uint_fast32_t *|uint32_t *|unsigned int *|uint_fast16_t *", 0, 0, (void*)0, 0};
5921 static swig_type_info _swigt__p_unsigned_long = {"_p_unsigned_long", "unsigned long *|time_t *", 0, 0, (void*)0, 0};
5922 static swig_type_info _swigt__p_unsigned_long_long = {"_p_unsigned_long_long", "uint_least64_t *|uint_fast64_t *|uint64_t *|unsigned long long *|uintmax_t *", 0, 0, (void*)0, 0};
5923 static swig_type_info _swigt__p_unsigned_short = {"_p_unsigned_short", "unsigned short *|uint_least16_t *|uint16_t *", 0, 0, (void*)0, 0};
5924 static swig_type_info _swigt__p_void = {"_p_void", "void *", 0, 0, (void*)0, 0};
5925
5926 static swig_type_info *swig_type_initial[] = {
5927   &_swigt__p_TALLOC_CTX,
5928   &_swigt__p_char,
5929   &_swigt__p_f_p_void_enum_ldb_debug_level_p_q_const__char_va_list__void,
5930   &_swigt__p_int,
5931   &_swigt__p_ldb_context,
5932   &_swigt__p_ldb_dn,
5933   &_swigt__p_ldb_ldif,
5934   &_swigt__p_ldb_message,
5935   &_swigt__p_ldb_message_element,
5936   &_swigt__p_ldb_module_ops,
5937   &_swigt__p_ldb_result,
5938   &_swigt__p_ldb_val,
5939   &_swigt__p_long_long,
5940   &_swigt__p_p_char,
5941   &_swigt__p_p_ldb_control,
5942   &_swigt__p_p_ldb_result,
5943   &_swigt__p_short,
5944   &_swigt__p_signed_char,
5945   &_swigt__p_unsigned_char,
5946   &_swigt__p_unsigned_int,
5947   &_swigt__p_unsigned_long,
5948   &_swigt__p_unsigned_long_long,
5949   &_swigt__p_unsigned_short,
5950   &_swigt__p_void,
5951 };
5952
5953 static swig_cast_info _swigc__p_TALLOC_CTX[] = {  {&_swigt__p_TALLOC_CTX, 0, 0, 0},{0, 0, 0, 0}};
5954 static swig_cast_info _swigc__p_char[] = {  {&_swigt__p_char, 0, 0, 0},{0, 0, 0, 0}};
5955 static swig_cast_info _swigc__p_f_p_void_enum_ldb_debug_level_p_q_const__char_va_list__void[] = {  {&_swigt__p_f_p_void_enum_ldb_debug_level_p_q_const__char_va_list__void, 0, 0, 0},{0, 0, 0, 0}};
5956 static swig_cast_info _swigc__p_int[] = {  {&_swigt__p_int, 0, 0, 0},{0, 0, 0, 0}};
5957 static swig_cast_info _swigc__p_ldb_context[] = {  {&_swigt__p_ldb_context, 0, 0, 0},{0, 0, 0, 0}};
5958 static swig_cast_info _swigc__p_ldb_dn[] = {  {&_swigt__p_ldb_dn, 0, 0, 0},{0, 0, 0, 0}};
5959 static swig_cast_info _swigc__p_ldb_ldif[] = {  {&_swigt__p_ldb_ldif, 0, 0, 0},{0, 0, 0, 0}};
5960 static swig_cast_info _swigc__p_ldb_message[] = {  {&_swigt__p_ldb_message, 0, 0, 0},{0, 0, 0, 0}};
5961 static swig_cast_info _swigc__p_ldb_message_element[] = {  {&_swigt__p_ldb_message_element, 0, 0, 0},{0, 0, 0, 0}};
5962 static swig_cast_info _swigc__p_ldb_module_ops[] = {  {&_swigt__p_ldb_module_ops, 0, 0, 0},{0, 0, 0, 0}};
5963 static swig_cast_info _swigc__p_ldb_result[] = {  {&_swigt__p_ldb_result, 0, 0, 0},{0, 0, 0, 0}};
5964 static swig_cast_info _swigc__p_ldb_val[] = {  {&_swigt__p_ldb_val, 0, 0, 0},{0, 0, 0, 0}};
5965 static swig_cast_info _swigc__p_long_long[] = {  {&_swigt__p_long_long, 0, 0, 0},{0, 0, 0, 0}};
5966 static swig_cast_info _swigc__p_p_char[] = {  {&_swigt__p_p_char, 0, 0, 0},{0, 0, 0, 0}};
5967 static swig_cast_info _swigc__p_p_ldb_control[] = {  {&_swigt__p_p_ldb_control, 0, 0, 0},{0, 0, 0, 0}};
5968 static swig_cast_info _swigc__p_p_ldb_result[] = {  {&_swigt__p_p_ldb_result, 0, 0, 0},{0, 0, 0, 0}};
5969 static swig_cast_info _swigc__p_short[] = {  {&_swigt__p_short, 0, 0, 0},{0, 0, 0, 0}};
5970 static swig_cast_info _swigc__p_signed_char[] = {  {&_swigt__p_signed_char, 0, 0, 0},{0, 0, 0, 0}};
5971 static swig_cast_info _swigc__p_unsigned_char[] = {  {&_swigt__p_unsigned_char, 0, 0, 0},{0, 0, 0, 0}};
5972 static swig_cast_info _swigc__p_unsigned_int[] = {  {&_swigt__p_unsigned_int, 0, 0, 0},{0, 0, 0, 0}};
5973 static swig_cast_info _swigc__p_unsigned_long[] = {  {&_swigt__p_unsigned_long, 0, 0, 0},{0, 0, 0, 0}};
5974 static swig_cast_info _swigc__p_unsigned_long_long[] = {  {&_swigt__p_unsigned_long_long, 0, 0, 0},{0, 0, 0, 0}};
5975 static swig_cast_info _swigc__p_unsigned_short[] = {  {&_swigt__p_unsigned_short, 0, 0, 0},{0, 0, 0, 0}};
5976 static swig_cast_info _swigc__p_void[] = {  {&_swigt__p_void, 0, 0, 0},{0, 0, 0, 0}};
5977
5978 static swig_cast_info *swig_cast_initial[] = {
5979   _swigc__p_TALLOC_CTX,
5980   _swigc__p_char,
5981   _swigc__p_f_p_void_enum_ldb_debug_level_p_q_const__char_va_list__void,
5982   _swigc__p_int,
5983   _swigc__p_ldb_context,
5984   _swigc__p_ldb_dn,
5985   _swigc__p_ldb_ldif,
5986   _swigc__p_ldb_message,
5987   _swigc__p_ldb_message_element,
5988   _swigc__p_ldb_module_ops,
5989   _swigc__p_ldb_result,
5990   _swigc__p_ldb_val,
5991   _swigc__p_long_long,
5992   _swigc__p_p_char,
5993   _swigc__p_p_ldb_control,
5994   _swigc__p_p_ldb_result,
5995   _swigc__p_short,
5996   _swigc__p_signed_char,
5997   _swigc__p_unsigned_char,
5998   _swigc__p_unsigned_int,
5999   _swigc__p_unsigned_long,
6000   _swigc__p_unsigned_long_long,
6001   _swigc__p_unsigned_short,
6002   _swigc__p_void,
6003 };
6004
6005
6006 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */
6007
6008 static swig_const_info swig_const_table[] = {
6009 {0, 0, 0, 0.0, 0, 0}};
6010
6011 #ifdef __cplusplus
6012 }
6013 #endif
6014 /* -----------------------------------------------------------------------------
6015  * Type initialization:
6016  * This problem is tough by the requirement that no dynamic
6017  * memory is used. Also, since swig_type_info structures store pointers to
6018  * swig_cast_info structures and swig_cast_info structures store pointers back
6019  * to swig_type_info structures, we need some lookup code at initialization.
6020  * The idea is that swig generates all the structures that are needed.
6021  * The runtime then collects these partially filled structures.
6022  * The SWIG_InitializeModule function takes these initial arrays out of
6023  * swig_module, and does all the lookup, filling in the swig_module.types
6024  * array with the correct data and linking the correct swig_cast_info
6025  * structures together.
6026  *
6027  * The generated swig_type_info structures are assigned staticly to an initial
6028  * array. We just loop through that array, and handle each type individually.
6029  * First we lookup if this type has been already loaded, and if so, use the
6030  * loaded structure instead of the generated one. Then we have to fill in the
6031  * cast linked list. The cast data is initially stored in something like a
6032  * two-dimensional array. Each row corresponds to a type (there are the same
6033  * number of rows as there are in the swig_type_initial array). Each entry in
6034  * a column is one of the swig_cast_info structures for that type.
6035  * The cast_initial array is actually an array of arrays, because each row has
6036  * a variable number of columns. So to actually build the cast linked list,
6037  * we find the array of casts associated with the type, and loop through it
6038  * adding the casts to the list. The one last trick we need to do is making
6039  * sure the type pointer in the swig_cast_info struct is correct.
6040  *
6041  * First off, we lookup the cast->type name to see if it is already loaded.
6042  * There are three cases to handle:
6043  *  1) If the cast->type has already been loaded AND the type we are adding
6044  *     casting info to has not been loaded (it is in this module), THEN we
6045  *     replace the cast->type pointer with the type pointer that has already
6046  *     been loaded.
6047  *  2) If BOTH types (the one we are adding casting info to, and the
6048  *     cast->type) are loaded, THEN the cast info has already been loaded by
6049  *     the previous module so we just ignore it.
6050  *  3) Finally, if cast->type has not already been loaded, then we add that
6051  *     swig_cast_info to the linked list (because the cast->type) pointer will
6052  *     be correct.
6053  * ----------------------------------------------------------------------------- */
6054
6055 #ifdef __cplusplus
6056 extern "C" {
6057 #if 0
6058 } /* c-mode */
6059 #endif
6060 #endif
6061
6062 #if 0
6063 #define SWIGRUNTIME_DEBUG
6064 #endif
6065
6066
6067 SWIGRUNTIME void
6068 SWIG_InitializeModule(void *clientdata) {
6069   size_t i;
6070   swig_module_info *module_head, *iter;
6071   int found, init;
6072
6073   clientdata = clientdata;
6074
6075   /* check to see if the circular list has been setup, if not, set it up */
6076   if (swig_module.next==0) {
6077     /* Initialize the swig_module */
6078     swig_module.type_initial = swig_type_initial;
6079     swig_module.cast_initial = swig_cast_initial;
6080     swig_module.next = &swig_module;
6081     init = 1;
6082   } else {
6083     init = 0;
6084   }
6085
6086   /* Try and load any already created modules */
6087   module_head = SWIG_GetModule(clientdata);
6088   if (!module_head) {
6089     /* This is the first module loaded for this interpreter */
6090     /* so set the swig module into the interpreter */
6091     SWIG_SetModule(clientdata, &swig_module);
6092     module_head = &swig_module;
6093   } else {
6094     /* the interpreter has loaded a SWIG module, but has it loaded this one? */
6095     found=0;
6096     iter=module_head;
6097     do {
6098       if (iter==&swig_module) {
6099         found=1;
6100         break;
6101       }
6102       iter=iter->next;
6103     } while (iter!= module_head);
6104
6105     /* if the is found in the list, then all is done and we may leave */
6106     if (found) return;
6107     /* otherwise we must add out module into the list */
6108     swig_module.next = module_head->next;
6109     module_head->next = &swig_module;
6110   }
6111
6112   /* When multiple interpeters are used, a module could have already been initialized in
6113        a different interpreter, but not yet have a pointer in this interpreter.
6114        In this case, we do not want to continue adding types... everything should be
6115        set up already */
6116   if (init == 0) return;
6117
6118   /* Now work on filling in swig_module.types */
6119 #ifdef SWIGRUNTIME_DEBUG
6120   printf("SWIG_InitializeModule: size %d\n", swig_module.size);
6121 #endif
6122   for (i = 0; i < swig_module.size; ++i) {
6123     swig_type_info *type = 0;
6124     swig_type_info *ret;
6125     swig_cast_info *cast;
6126
6127 #ifdef SWIGRUNTIME_DEBUG
6128     printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
6129 #endif
6130
6131     /* if there is another module already loaded */
6132     if (swig_module.next != &swig_module) {
6133       type = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, swig_module.type_initial[i]->name);
6134     }
6135     if (type) {
6136       /* Overwrite clientdata field */
6137 #ifdef SWIGRUNTIME_DEBUG
6138       printf("SWIG_InitializeModule: found type %s\n", type->name);
6139 #endif
6140       if (swig_module.type_initial[i]->clientdata) {
6141         type->clientdata = swig_module.type_initial[i]->clientdata;
6142 #ifdef SWIGRUNTIME_DEBUG
6143         printf("SWIG_InitializeModule: found and overwrite type %s \n", type->name);
6144 #endif
6145       }
6146     } else {
6147       type = swig_module.type_initial[i];
6148     }
6149
6150     /* Insert casting types */
6151     cast = swig_module.cast_initial[i];
6152     while (cast->type) {
6153       /* Don't need to add information already in the list */
6154       ret = 0;
6155 #ifdef SWIGRUNTIME_DEBUG
6156       printf("SWIG_InitializeModule: look cast %s\n", cast->type->name);
6157 #endif
6158       if (swig_module.next != &swig_module) {
6159         ret = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, cast->type->name);
6160 #ifdef SWIGRUNTIME_DEBUG
6161         if (ret) printf("SWIG_InitializeModule: found cast %s\n", ret->name);
6162 #endif
6163       }
6164       if (ret) {
6165         if (type == swig_module.type_initial[i]) {
6166 #ifdef SWIGRUNTIME_DEBUG
6167           printf("SWIG_InitializeModule: skip old type %s\n", ret->name);
6168 #endif
6169           cast->type = ret;
6170           ret = 0;
6171         } else {
6172           /* Check for casting already in the list */
6173           swig_cast_info *ocast = SWIG_TypeCheck(ret->name, type);
6174 #ifdef SWIGRUNTIME_DEBUG
6175           if (ocast) printf("SWIG_InitializeModule: skip old cast %s\n", ret->name);
6176 #endif
6177           if (!ocast) ret = 0;
6178         }
6179       }
6180
6181       if (!ret) {
6182 #ifdef SWIGRUNTIME_DEBUG
6183         printf("SWIG_InitializeModule: adding cast %s\n", cast->type->name);
6184 #endif
6185         if (type->cast) {
6186           type->cast->prev = cast;
6187           cast->next = type->cast;
6188         }
6189         type->cast = cast;
6190       }
6191       cast++;
6192     }
6193     /* Set entry in modules->types array equal to the type */
6194     swig_module.types[i] = type;
6195   }
6196   swig_module.types[i] = 0;
6197
6198 #ifdef SWIGRUNTIME_DEBUG
6199   printf("**** SWIG_InitializeModule: Cast List ******\n");
6200   for (i = 0; i < swig_module.size; ++i) {
6201     int j = 0;
6202     swig_cast_info *cast = swig_module.cast_initial[i];
6203     printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
6204     while (cast->type) {
6205       printf("SWIG_InitializeModule: cast type %s\n", cast->type->name);
6206       cast++;
6207       ++j;
6208     }
6209     printf("---- Total casts: %d\n",j);
6210   }
6211   printf("**** SWIG_InitializeModule: Cast List ******\n");
6212 #endif
6213 }
6214
6215 /* This function will propagate the clientdata field of type to
6216 * any new swig_type_info structures that have been added into the list
6217 * of equivalent types.  It is like calling
6218 * SWIG_TypeClientData(type, clientdata) a second time.
6219 */
6220 SWIGRUNTIME void
6221 SWIG_PropagateClientData(void) {
6222   size_t i;
6223   swig_cast_info *equiv;
6224   static int init_run = 0;
6225
6226   if (init_run) return;
6227   init_run = 1;
6228
6229   for (i = 0; i < swig_module.size; i++) {
6230     if (swig_module.types[i]->clientdata) {
6231       equiv = swig_module.types[i]->cast;
6232       while (equiv) {
6233         if (!equiv->converter) {
6234           if (equiv->type && !equiv->type->clientdata)
6235           SWIG_TypeClientData(equiv->type, swig_module.types[i]->clientdata);
6236         }
6237         equiv = equiv->next;
6238       }
6239     }
6240   }
6241 }
6242
6243 #ifdef __cplusplus
6244 #if 0
6245 {
6246   /* c-mode */
6247 #endif
6248 }
6249 #endif
6250
6251
6252
6253 #ifdef __cplusplus
6254 extern "C" {
6255 #endif
6256
6257   /* Python-specific SWIG API */
6258 #define SWIG_newvarlink()                             SWIG_Python_newvarlink()
6259 #define SWIG_addvarlink(p, name, get_attr, set_attr)  SWIG_Python_addvarlink(p, name, get_attr, set_attr)
6260 #define SWIG_InstallConstants(d, constants)           SWIG_Python_InstallConstants(d, constants)
6261
6262   /* -----------------------------------------------------------------------------
6263    * global variable support code.
6264    * ----------------------------------------------------------------------------- */
6265
6266   typedef struct swig_globalvar {
6267     char       *name;                  /* Name of global variable */
6268     PyObject *(*get_attr)(void);       /* Return the current value */
6269     int       (*set_attr)(PyObject *); /* Set the value */
6270     struct swig_globalvar *next;
6271   } swig_globalvar;
6272
6273   typedef struct swig_varlinkobject {
6274     PyObject_HEAD
6275     swig_globalvar *vars;
6276   } swig_varlinkobject;
6277
6278   SWIGINTERN PyObject *
6279   swig_varlink_repr(swig_varlinkobject *SWIGUNUSEDPARM(v)) {
6280     return PyString_FromString("<Swig global variables>");
6281   }
6282
6283   SWIGINTERN PyObject *
6284   swig_varlink_str(swig_varlinkobject *v) {
6285     PyObject *str = PyString_FromString("(");
6286     swig_globalvar  *var;
6287     for (var = v->vars; var; var=var->next) {
6288       PyString_ConcatAndDel(&str,PyString_FromString(var->name));
6289       if (var->next) PyString_ConcatAndDel(&str,PyString_FromString(", "));
6290     }
6291     PyString_ConcatAndDel(&str,PyString_FromString(")"));
6292     return str;
6293   }
6294
6295   SWIGINTERN int
6296   swig_varlink_print(swig_varlinkobject *v, FILE *fp, int SWIGUNUSEDPARM(flags)) {
6297     PyObject *str = swig_varlink_str(v);
6298     fprintf(fp,"Swig global variables ");
6299     fprintf(fp,"%s\n", PyString_AsString(str));
6300     Py_DECREF(str);
6301     return 0;
6302   }
6303
6304   SWIGINTERN void
6305   swig_varlink_dealloc(swig_varlinkobject *v) {
6306     swig_globalvar *var = v->vars;
6307     while (var) {
6308       swig_globalvar *n = var->next;
6309       free(var->name);
6310       free(var);
6311       var = n;
6312     }
6313   }
6314
6315   SWIGINTERN PyObject *
6316   swig_varlink_getattr(swig_varlinkobject *v, char *n) {
6317     PyObject *res = NULL;
6318     swig_globalvar *var = v->vars;
6319     while (var) {
6320       if (strcmp(var->name,n) == 0) {
6321         res = (*var->get_attr)();
6322         break;
6323       }
6324       var = var->next;
6325     }
6326     if (res == NULL && !PyErr_Occurred()) {
6327       PyErr_SetString(PyExc_NameError,"Unknown C global variable");
6328     }
6329     return res;
6330   }
6331
6332   SWIGINTERN int
6333   swig_varlink_setattr(swig_varlinkobject *v, char *n, PyObject *p) {
6334     int res = 1;
6335     swig_globalvar *var = v->vars;
6336     while (var) {
6337       if (strcmp(var->name,n) == 0) {
6338         res = (*var->set_attr)(p);
6339         break;
6340       }
6341       var = var->next;
6342     }
6343     if (res == 1 && !PyErr_Occurred()) {
6344       PyErr_SetString(PyExc_NameError,"Unknown C global variable");
6345     }
6346     return res;
6347   }
6348
6349   SWIGINTERN PyTypeObject*
6350   swig_varlink_type(void) {
6351     static char varlink__doc__[] = "Swig var link object";
6352     static PyTypeObject varlink_type;
6353     static int type_init = 0;
6354     if (!type_init) {
6355       const PyTypeObject tmp
6356       = {
6357         PyObject_HEAD_INIT(NULL)
6358         0,                                  /* Number of items in variable part (ob_size) */
6359         (char *)"swigvarlink",              /* Type name (tp_name) */
6360         sizeof(swig_varlinkobject),         /* Basic size (tp_basicsize) */
6361         0,                                  /* Itemsize (tp_itemsize) */
6362         (destructor) swig_varlink_dealloc,   /* Deallocator (tp_dealloc) */
6363         (printfunc) swig_varlink_print,     /* Print (tp_print) */
6364         (getattrfunc) swig_varlink_getattr, /* get attr (tp_getattr) */
6365         (setattrfunc) swig_varlink_setattr, /* Set attr (tp_setattr) */
6366         0,                                  /* tp_compare */
6367         (reprfunc) swig_varlink_repr,       /* tp_repr */
6368         0,                                  /* tp_as_number */
6369         0,                                  /* tp_as_sequence */
6370         0,                                  /* tp_as_mapping */
6371         0,                                  /* tp_hash */
6372         0,                                  /* tp_call */
6373         (reprfunc)swig_varlink_str,        /* tp_str */
6374         0,                                  /* tp_getattro */
6375         0,                                  /* tp_setattro */
6376         0,                                  /* tp_as_buffer */
6377         0,                                  /* tp_flags */
6378         varlink__doc__,                     /* tp_doc */
6379         0,                                  /* tp_traverse */
6380         0,                                  /* tp_clear */
6381         0,                                  /* tp_richcompare */
6382         0,                                  /* tp_weaklistoffset */
6383 #if PY_VERSION_HEX >= 0x02020000
6384         0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
6385 #endif
6386 #if PY_VERSION_HEX >= 0x02030000
6387         0,                                  /* tp_del */
6388 #endif
6389 #ifdef COUNT_ALLOCS
6390         0,0,0,0                             /* tp_alloc -> tp_next */
6391 #endif
6392       };
6393       varlink_type = tmp;
6394       varlink_type.ob_type = &PyType_Type;
6395       type_init = 1;
6396     }
6397     return &varlink_type;
6398   }
6399
6400   /* Create a variable linking object for use later */
6401   SWIGINTERN PyObject *
6402   SWIG_Python_newvarlink(void) {
6403     swig_varlinkobject *result = PyObject_NEW(swig_varlinkobject, swig_varlink_type());
6404     if (result) {
6405       result->vars = 0;
6406     }
6407     return ((PyObject*) result);
6408   }
6409
6410   SWIGINTERN void
6411   SWIG_Python_addvarlink(PyObject *p, char *name, PyObject *(*get_attr)(void), int (*set_attr)(PyObject *p)) {
6412     swig_varlinkobject *v = (swig_varlinkobject *) p;
6413     swig_globalvar *gv = (swig_globalvar *) malloc(sizeof(swig_globalvar));
6414     if (gv) {
6415       size_t size = strlen(name)+1;
6416       gv->name = (char *)malloc(size);
6417       if (gv->name) {
6418         strncpy(gv->name,name,size);
6419         gv->get_attr = get_attr;
6420         gv->set_attr = set_attr;
6421         gv->next = v->vars;
6422       }
6423     }
6424     v->vars = gv;
6425   }
6426
6427   SWIGINTERN PyObject *
6428   SWIG_globals(void) {
6429     static PyObject *_SWIG_globals = 0;
6430     if (!_SWIG_globals) _SWIG_globals = SWIG_newvarlink();
6431     return _SWIG_globals;
6432   }
6433
6434   /* -----------------------------------------------------------------------------
6435    * constants/methods manipulation
6436    * ----------------------------------------------------------------------------- */
6437
6438   /* Install Constants */
6439   SWIGINTERN void
6440   SWIG_Python_InstallConstants(PyObject *d, swig_const_info constants[]) {
6441     PyObject *obj = 0;
6442     size_t i;
6443     for (i = 0; constants[i].type; ++i) {
6444       switch(constants[i].type) {
6445       case SWIG_PY_POINTER:
6446         obj = SWIG_NewPointerObj(constants[i].pvalue, *(constants[i]).ptype,0);
6447         break;
6448       case SWIG_PY_BINARY:
6449         obj = SWIG_NewPackedObj(constants[i].pvalue, constants[i].lvalue, *(constants[i].ptype));
6450         break;
6451       default:
6452         obj = 0;
6453         break;
6454       }
6455       if (obj) {
6456         PyDict_SetItemString(d, constants[i].name, obj);
6457         Py_DECREF(obj);
6458       }
6459     }
6460   }
6461
6462   /* -----------------------------------------------------------------------------*/
6463   /* Fix SwigMethods to carry the callback ptrs when needed */
6464   /* -----------------------------------------------------------------------------*/
6465
6466   SWIGINTERN void
6467   SWIG_Python_FixMethods(PyMethodDef *methods,
6468     swig_const_info *const_table,
6469     swig_type_info **types,
6470     swig_type_info **types_initial) {
6471     size_t i;
6472     for (i = 0; methods[i].ml_name; ++i) {
6473       const char *c = methods[i].ml_doc;
6474       if (c && (c = strstr(c, "swig_ptr: "))) {
6475         int j;
6476         swig_const_info *ci = 0;
6477         const char *name = c + 10;
6478         for (j = 0; const_table[j].type; ++j) {
6479           if (strncmp(const_table[j].name, name,
6480               strlen(const_table[j].name)) == 0) {
6481             ci = &(const_table[j]);
6482             break;
6483           }
6484         }
6485         if (ci) {
6486           size_t shift = (ci->ptype) - types;
6487           swig_type_info *ty = types_initial[shift];
6488           size_t ldoc = (c - methods[i].ml_doc);
6489           size_t lptr = strlen(ty->name)+2*sizeof(void*)+2;
6490           char *ndoc = (char*)malloc(ldoc + lptr + 10);
6491           if (ndoc) {
6492             char *buff = ndoc;
6493             void *ptr = (ci->type == SWIG_PY_POINTER) ? ci->pvalue : 0;
6494             if (ptr) {
6495               strncpy(buff, methods[i].ml_doc, ldoc);
6496               buff += ldoc;
6497               strncpy(buff, "swig_ptr: ", 10);
6498               buff += 10;
6499               SWIG_PackVoidPtr(buff, ptr, ty->name, lptr);
6500               methods[i].ml_doc = ndoc;
6501             }
6502           }
6503         }
6504       }
6505     }
6506   }
6507
6508 #ifdef __cplusplus
6509 }
6510 #endif
6511
6512 /* -----------------------------------------------------------------------------*
6513  *  Partial Init method
6514  * -----------------------------------------------------------------------------*/
6515
6516 #ifdef __cplusplus
6517 extern "C"
6518 #endif
6519 SWIGEXPORT void SWIG_init(void) {
6520   PyObject *m, *d;
6521
6522   /* Fix SwigMethods to carry the callback ptrs when needed */
6523   SWIG_Python_FixMethods(SwigMethods, swig_const_table, swig_types, swig_type_initial);
6524
6525   m = Py_InitModule((char *) SWIG_name, SwigMethods);
6526   d = PyModule_GetDict(m);
6527
6528   SWIG_InitializeModule(0);
6529   SWIG_InstallConstants(d,swig_const_table);
6530
6531
6532   SWIG_Python_SetConstant(d, "SCOPE_DEFAULT",SWIG_From_int((int)(LDB_SCOPE_DEFAULT)));
6533   SWIG_Python_SetConstant(d, "SCOPE_BASE",SWIG_From_int((int)(LDB_SCOPE_BASE)));
6534   SWIG_Python_SetConstant(d, "SCOPE_ONELEVEL",SWIG_From_int((int)(LDB_SCOPE_ONELEVEL)));
6535   SWIG_Python_SetConstant(d, "SCOPE_SUBTREE",SWIG_From_int((int)(LDB_SCOPE_SUBTREE)));
6536   SWIG_Python_SetConstant(d, "CHANGETYPE_NONE",SWIG_From_int((int)(LDB_CHANGETYPE_NONE)));
6537   SWIG_Python_SetConstant(d, "CHANGETYPE_ADD",SWIG_From_int((int)(LDB_CHANGETYPE_ADD)));
6538   SWIG_Python_SetConstant(d, "CHANGETYPE_DELETE",SWIG_From_int((int)(LDB_CHANGETYPE_DELETE)));
6539   SWIG_Python_SetConstant(d, "CHANGETYPE_MODIFY",SWIG_From_int((int)(LDB_CHANGETYPE_MODIFY)));
6540
6541   PyExc_LdbError = PyErr_NewException((char *)"_ldb.LdbError", NULL, NULL);
6542   PyDict_SetItemString(d, "LdbError", PyExc_LdbError);
6543
6544   SWIG_Python_SetConstant(d, "LDB_ERR_OPERATIONS_ERROR",SWIG_From_int((int)(1)));
6545   SWIG_Python_SetConstant(d, "LDB_ERR_PROTOCOL_ERROR",SWIG_From_int((int)(2)));
6546   SWIG_Python_SetConstant(d, "LDB_ERR_TIME_LIMIT_EXCEEDED",SWIG_From_int((int)(3)));
6547   SWIG_Python_SetConstant(d, "LDB_ERR_SIZE_LIMIT_EXCEEDED",SWIG_From_int((int)(4)));
6548   SWIG_Python_SetConstant(d, "LDB_ERR_COMPARE_FALSE",SWIG_From_int((int)(5)));
6549   SWIG_Python_SetConstant(d, "LDB_ERR_COMPARE_TRUE",SWIG_From_int((int)(6)));
6550   SWIG_Python_SetConstant(d, "LDB_ERR_AUTH_METHOD_NOT_SUPPORTED",SWIG_From_int((int)(7)));
6551   SWIG_Python_SetConstant(d, "LDB_ERR_STRONG_AUTH_REQUIRED",SWIG_From_int((int)(8)));
6552   SWIG_Python_SetConstant(d, "LDB_ERR_REFERRAL",SWIG_From_int((int)(10)));
6553   SWIG_Python_SetConstant(d, "LDB_ERR_ADMIN_LIMIT_EXCEEDED",SWIG_From_int((int)(11)));
6554   SWIG_Python_SetConstant(d, "LDB_ERR_UNSUPPORTED_CRITICAL_EXTENSION",SWIG_From_int((int)(12)));
6555   SWIG_Python_SetConstant(d, "LDB_ERR_CONFIDENTIALITY_REQUIRED",SWIG_From_int((int)(13)));
6556   SWIG_Python_SetConstant(d, "LDB_ERR_SASL_BIND_IN_PROGRESS",SWIG_From_int((int)(14)));
6557   SWIG_Python_SetConstant(d, "LDB_ERR_NO_SUCH_ATTRIBUTE",SWIG_From_int((int)(16)));
6558   SWIG_Python_SetConstant(d, "LDB_ERR_UNDEFINED_ATTRIBUTE_TYPE",SWIG_From_int((int)(17)));
6559   SWIG_Python_SetConstant(d, "LDB_ERR_INAPPROPRIATE_MATCHING",SWIG_From_int((int)(18)));
6560   SWIG_Python_SetConstant(d, "LDB_ERR_CONSTRAINT_VIOLATION",SWIG_From_int((int)(19)));
6561   SWIG_Python_SetConstant(d, "LDB_ERR_ATTRIBUTE_OR_VALUE_EXISTS",SWIG_From_int((int)(20)));
6562   SWIG_Python_SetConstant(d, "LDB_ERR_INVALID_ATTRIBUTE_SYNTAX",SWIG_From_int((int)(21)));
6563   SWIG_Python_SetConstant(d, "LDB_ERR_NO_SUCH_OBJECT",SWIG_From_int((int)(32)));
6564   SWIG_Python_SetConstant(d, "LDB_ERR_ALIAS_PROBLEM",SWIG_From_int((int)(33)));
6565   SWIG_Python_SetConstant(d, "LDB_ERR_INVALID_DN_SYNTAX",SWIG_From_int((int)(34)));
6566   SWIG_Python_SetConstant(d, "LDB_ERR_ALIAS_DEREFERENCING_PROBLEM",SWIG_From_int((int)(36)));
6567   SWIG_Python_SetConstant(d, "LDB_ERR_INAPPROPRIATE_AUTHENTICATION",SWIG_From_int((int)(48)));
6568   SWIG_Python_SetConstant(d, "LDB_ERR_INVALID_CREDENTIALS",SWIG_From_int((int)(49)));
6569   SWIG_Python_SetConstant(d, "LDB_ERR_INSUFFICIENT_ACCESS_RIGHTS",SWIG_From_int((int)(50)));
6570   SWIG_Python_SetConstant(d, "LDB_ERR_BUSY",SWIG_From_int((int)(51)));
6571   SWIG_Python_SetConstant(d, "LDB_ERR_UNAVAILABLE",SWIG_From_int((int)(52)));
6572   SWIG_Python_SetConstant(d, "LDB_ERR_UNWILLING_TO_PERFORM",SWIG_From_int((int)(53)));
6573   SWIG_Python_SetConstant(d, "LDB_ERR_LOOP_DETECT",SWIG_From_int((int)(54)));
6574   SWIG_Python_SetConstant(d, "LDB_ERR_NAMING_VIOLATION",SWIG_From_int((int)(64)));
6575   SWIG_Python_SetConstant(d, "LDB_ERR_OBJECT_CLASS_VIOLATION",SWIG_From_int((int)(65)));
6576   SWIG_Python_SetConstant(d, "LDB_ERR_NOT_ALLOWED_ON_NON_LEAF",SWIG_From_int((int)(66)));
6577   SWIG_Python_SetConstant(d, "LDB_ERR_NOT_ALLOWED_ON_RDN",SWIG_From_int((int)(67)));
6578   SWIG_Python_SetConstant(d, "LDB_ERR_ENTRY_ALREADY_EXISTS",SWIG_From_int((int)(68)));
6579   SWIG_Python_SetConstant(d, "LDB_ERR_OBJECT_CLASS_MODS_PROHIBITED",SWIG_From_int((int)(69)));
6580   SWIG_Python_SetConstant(d, "LDB_ERR_AFFECTS_MULTIPLE_DSAS",SWIG_From_int((int)(71)));
6581   SWIG_Python_SetConstant(d, "LDB_ERR_OTHER",SWIG_From_int((int)(80)));
6582 }
6583