source4/lib/ldb/ldb_wrap.c

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