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_request swig_types[12]
2499 #define SWIGTYPE_p_ldb_result swig_types[13]
2500 #define SWIGTYPE_p_ldb_val swig_types[14]
2501 #define SWIGTYPE_p_long_long swig_types[15]
2502 #define SWIGTYPE_p_p_char swig_types[16]
2503 #define SWIGTYPE_p_p_ldb_control swig_types[17]
2504 #define SWIGTYPE_p_p_ldb_result swig_types[18]
2505 #define SWIGTYPE_p_short swig_types[19]
2506 #define SWIGTYPE_p_signed_char swig_types[20]
2507 #define SWIGTYPE_p_unsigned_char swig_types[21]
2508 #define SWIGTYPE_p_unsigned_int swig_types[22]
2509 #define SWIGTYPE_p_unsigned_long swig_types[23]
2510 #define SWIGTYPE_p_unsigned_long_long swig_types[24]
2511 #define SWIGTYPE_p_unsigned_short swig_types[25]
2512 #define SWIGTYPE_p_void swig_types[26]
2513 static swig_type_info *swig_types[28];
2514 static swig_module_info swig_module = {swig_types, 27, 0, 0, 0, 0};
2515 #define SWIG_TypeQuery(name) SWIG_TypeQueryModule(&swig_module, &swig_module, name)
2516 #define SWIG_MangledTypeQuery(name) SWIG_MangledTypeQueryModule(&swig_module, &swig_module, name)
2517
2518 /* -------- TYPES TABLE (END) -------- */
2519
2520 #if (PY_VERSION_HEX <= 0x02000000)
2521 # if !defined(SWIG_PYTHON_CLASSIC)
2522 #  error "This python version requires swig to be run with the '-classic' option"
2523 # endif
2524 #endif
2525 #if (PY_VERSION_HEX <= 0x02020000)
2526 # error "This python version requires swig to be run with the '-nomodern' option"
2527 #endif
2528 #if (PY_VERSION_HEX <= 0x02020000)
2529 # error "This python version requires swig to be run with the '-nomodernargs' option"
2530 #endif
2531 #ifndef METH_O
2532 # error "This python version requires swig to be run with the '-nofastunpack' option"
2533 #endif
2534 #ifdef SWIG_TypeQuery
2535 # undef SWIG_TypeQuery
2536 #endif
2537 #define SWIG_TypeQuery SWIG_Python_TypeQuery
2538
2539 /*-----------------------------------------------
2540               @(target):= _ldb.so
2541   ------------------------------------------------*/
2542 #define SWIG_init    init_ldb
2543
2544 #define SWIG_name    "_ldb"
2545
2546 #define SWIGVERSION 0x010336
2547 #define SWIG_VERSION SWIGVERSION
2548
2549
2550 #define SWIG_as_voidptr(a) (void *)((const void *)(a))
2551 #define SWIG_as_voidptrptr(a) ((void)SWIG_as_voidptr(*a),(void**)(a))
2552
2553
2554
2555 #include <stdint.h>
2556 #include <stdbool.h>
2557 #include "talloc.h"
2558 #include "events.h"
2559 #include "ldb.h"
2560 #include "ldb_errors.h"
2561 #include "ldb_private.h"
2562
2563 typedef struct ldb_message ldb_msg;
2564 typedef struct ldb_context ldb;
2565 typedef struct ldb_dn ldb_dn;
2566 typedef struct ldb_ldif ldb_ldif;
2567 typedef struct ldb_message_element ldb_message_element;
2568 typedef struct ldb_module ldb_module;
2569 typedef int ldb_error;
2570 typedef int ldb_int_error;
2571
2572
2573
2574   #define SWIG_From_long   PyInt_FromLong
2575
2576
2577 SWIGINTERNINLINE PyObject *
2578 SWIG_From_int  (int value)
2579 {
2580   return SWIG_From_long  (value);
2581 }
2582
2583
2584 PyObject *ldb_val_to_py_object(struct ldb_context *ldb_ctx,
2585                                struct ldb_message_element *el,
2586                                struct ldb_val *val)
2587 {
2588         const struct ldb_schema_attribute *a;
2589         struct ldb_val new_val;
2590         TALLOC_CTX *mem_ctx = talloc_new(NULL);
2591         PyObject *ret;
2592
2593         new_val = *val;
2594
2595         if (ldb_ctx != NULL) {
2596                 a = ldb_schema_attribute_by_name(ldb_ctx, el->name);
2597
2598                 if (a != NULL) {
2599                         if (a->syntax->ldif_write_fn(ldb_ctx, mem_ctx, val, &new_val) != 0) {
2600                                 talloc_free(mem_ctx);
2601                                 return NULL;
2602                         }
2603                 }
2604         }
2605
2606         ret = PyString_FromStringAndSize((const char *)new_val.data, new_val.length);
2607
2608         talloc_free(mem_ctx);
2609
2610         return ret;
2611 }
2612
2613
2614
2615 SWIGINTERN swig_type_info*
2616 SWIG_pchar_descriptor(void)
2617 {
2618   static int init = 0;
2619   static swig_type_info* info = 0;
2620   if (!init) {
2621     info = SWIG_TypeQuery("_p_char");
2622     init = 1;
2623   }
2624   return info;
2625 }
2626
2627
2628 SWIGINTERN int
2629 SWIG_AsCharPtrAndSize(PyObject *obj, char** cptr, size_t* psize, int *alloc)
2630 {
2631   if (PyString_Check(obj)) {
2632     char *cstr; Py_ssize_t len;
2633     PyString_AsStringAndSize(obj, &cstr, &len);
2634     if (cptr)  {
2635       if (alloc) {
2636         /*
2637            In python the user should not be able to modify the inner
2638            string representation. To warranty that, if you define
2639            SWIG_PYTHON_SAFE_CSTRINGS, a new/copy of the python string
2640            buffer is always returned.
2641
2642            The default behavior is just to return the pointer value,
2643            so, be careful.
2644         */
2645 #if defined(SWIG_PYTHON_SAFE_CSTRINGS)
2646         if (*alloc != SWIG_OLDOBJ)
2647 #else
2648         if (*alloc == SWIG_NEWOBJ)
2649 #endif
2650           {
2651             *cptr = (char *)memcpy((char *)malloc((len + 1)*sizeof(char)), cstr, sizeof(char)*(len + 1));
2652             *alloc = SWIG_NEWOBJ;
2653           }
2654         else {
2655           *cptr = cstr;
2656           *alloc = SWIG_OLDOBJ;
2657         }
2658       } else {
2659         *cptr = PyString_AsString(obj);
2660       }
2661     }
2662     if (psize) *psize = len + 1;
2663     return SWIG_OK;
2664   } else {
2665     swig_type_info* pchar_descriptor = SWIG_pchar_descriptor();
2666     if (pchar_descriptor) {
2667       void* vptr = 0;
2668       if (SWIG_ConvertPtr(obj, &vptr, pchar_descriptor, 0) == SWIG_OK) {
2669         if (cptr) *cptr = (char *) vptr;
2670         if (psize) *psize = vptr ? (strlen((char *)vptr) + 1) : 0;
2671         if (alloc) *alloc = SWIG_OLDOBJ;
2672         return SWIG_OK;
2673       }
2674     }
2675   }
2676   return SWIG_TypeError;
2677 }
2678
2679
2680
2681
2682 SWIGINTERN ldb_dn *new_ldb_dn(ldb *ldb_ctx,char const *str){
2683             ldb_dn *ret = ldb_dn_new(ldb_ctx, ldb_ctx, str);
2684             /* ldb_dn_new() doesn't accept NULL as memory context, so
2685                we do it this way... */
2686             talloc_steal(NULL, ret);
2687
2688             if (ret == NULL)
2689                 SWIG_exception(SWIG_ValueError,
2690                                 "unable to parse dn string");
2691 fail:
2692             return ret;
2693         }
2694 SWIGINTERN void delete_ldb_dn(ldb_dn *self){ talloc_free(self); }
2695
2696 SWIGINTERNINLINE PyObject*
2697   SWIG_From_bool  (bool value)
2698 {
2699   return PyBool_FromLong(value ? 1 : 0);
2700 }
2701
2702
2703 SWIGINTERNINLINE PyObject *
2704 SWIG_FromCharPtrAndSize(const char* carray, size_t size)
2705 {
2706   if (carray) {
2707     if (size > INT_MAX) {
2708       swig_type_info* pchar_descriptor = SWIG_pchar_descriptor();
2709       return pchar_descriptor ?
2710         SWIG_NewPointerObj((char *)(carray), pchar_descriptor, 0) : SWIG_Py_Void();
2711     } else {
2712       return PyString_FromStringAndSize(carray, (int)(size));
2713     }
2714   } else {
2715     return SWIG_Py_Void();
2716   }
2717 }
2718
2719
2720 SWIGINTERNINLINE PyObject *
2721 SWIG_FromCharPtr(const char *cptr)
2722 {
2723   return SWIG_FromCharPtrAndSize(cptr, (cptr ? strlen(cptr) : 0));
2724 }
2725
2726 SWIGINTERN ldb_dn *ldb_dn_parent(ldb_dn *self){ return ldb_dn_get_parent(NULL, self); }
2727 SWIGINTERN char const *ldb_dn_canonical_str(ldb_dn *self){
2728             return ldb_dn_canonical_string(self, self);
2729         }
2730 SWIGINTERN char const *ldb_dn_canonical_ex_str(ldb_dn *self){
2731             return ldb_dn_canonical_ex_string(self, self);
2732         }
2733 SWIGINTERN char *ldb_dn___repr__(ldb_dn *self){
2734             char *dn = ldb_dn_get_linearized(self), *ret;
2735             asprintf(&ret, "Dn('%s')", dn);
2736             talloc_free(dn);
2737             return ret;
2738         }
2739 SWIGINTERN ldb_dn *ldb_dn___add__(ldb_dn *self,ldb_dn *other){
2740             ldb_dn *ret = ldb_dn_copy(NULL, self);
2741             ldb_dn_add_child(ret, other);
2742             return ret;
2743         }
2744
2745 struct ldb_context *ldb_context_from_py_object(PyObject *py_obj)
2746 {
2747         struct ldb_context *ldb_ctx;
2748     if (SWIG_ConvertPtr(py_obj, (void *)&ldb_ctx, SWIGTYPE_p_ldb_context, 0 |  0 ) < 0)
2749         return NULL;
2750     return ldb_ctx;
2751 }
2752
2753 int ldb_dn_from_pyobject(TALLOC_CTX *mem_ctx, PyObject *object,
2754                          struct ldb_context *ldb_ctx, ldb_dn **dn)
2755 {
2756     int ret;
2757     struct ldb_dn *odn;
2758     if (ldb_ctx != NULL && PyString_Check(object)) {
2759         odn = ldb_dn_new(mem_ctx, ldb_ctx, PyString_AsString(object));
2760         if (!odn) {
2761                 return SWIG_ERROR;
2762         }
2763         *dn = odn;
2764         return 0;
2765     }
2766     ret = SWIG_ConvertPtr(object, (void **)&odn, SWIGTYPE_p_ldb_dn,
2767                            SWIG_POINTER_EXCEPTION);
2768     *dn = ldb_dn_copy(mem_ctx, odn);
2769     if (odn && !*dn) {
2770         return SWIG_ERROR;
2771     }
2772     return ret;
2773 }
2774
2775 ldb_message_element *ldb_msg_element_from_pyobject(TALLOC_CTX *mem_ctx,
2776                                                PyObject *set_obj, int flags,
2777                                                const char *attr_name)
2778 {
2779     struct ldb_message_element *me = talloc(mem_ctx, struct ldb_message_element);
2780     me->name = attr_name;
2781     me->flags = flags;
2782     if (PyString_Check(set_obj)) {
2783         me->num_values = 1;
2784         me->values = talloc_array(me, struct ldb_val, me->num_values);
2785         me->values[0].length = PyString_Size(set_obj);
2786         me->values[0].data = (uint8_t *)talloc_strdup(me->values,
2787                                            PyString_AsString(set_obj));
2788     } else if (PySequence_Check(set_obj)) {
2789         int i;
2790         me->num_values = PySequence_Size(set_obj);
2791         me->values = talloc_array(me, struct ldb_val, me->num_values);
2792         for (i = 0; i < me->num_values; i++) {
2793             PyObject *obj = PySequence_GetItem(set_obj, i);
2794             me->values[i].length = PyString_Size(obj);
2795             me->values[i].data = (uint8_t *)PyString_AsString(obj);
2796         }
2797     } else {
2798         talloc_free(me);
2799         me = NULL;
2800     }
2801
2802     return me;
2803 }
2804
2805 PyObject *ldb_msg_element_to_set(struct ldb_context *ldb_ctx,
2806                                  ldb_message_element *me)
2807 {
2808     int i;
2809     PyObject *result;
2810
2811     /* Python << 2.5 doesn't have PySet_New and PySet_Add. */
2812     result = PyList_New(me->num_values);
2813
2814     for (i = 0; i < me->num_values; i++) {
2815         PyList_SetItem(result, i,
2816             ldb_val_to_py_object(ldb_ctx, me, &me->values[i]));
2817     }
2818
2819     return result;
2820 }
2821
2822
2823 SWIGINTERN int ldb_message_element___cmp__(ldb_message_element *self,ldb_message_element *other){
2824             return ldb_msg_element_compare(self, other);
2825         }
2826 SWIGINTERN PyObject *ldb_message_element___iter__(ldb_message_element *self){
2827             return PyObject_GetIter(ldb_msg_element_to_set(NULL, self));
2828         }
2829 SWIGINTERN PyObject *ldb_message_element___set__(ldb_message_element *self){
2830             return ldb_msg_element_to_set(NULL, self);
2831         }
2832
2833 #include <limits.h>
2834 #if !defined(SWIG_NO_LLONG_MAX)
2835 # if !defined(LLONG_MAX) && defined(__GNUC__) && defined (__LONG_LONG_MAX__)
2836 #   define LLONG_MAX __LONG_LONG_MAX__
2837 #   define LLONG_MIN (-LLONG_MAX - 1LL)
2838 #   define ULLONG_MAX (LLONG_MAX * 2ULL + 1ULL)
2839 # endif
2840 #endif
2841
2842
2843 SWIGINTERN int
2844 SWIG_AsVal_double (PyObject *obj, double *val)
2845 {
2846   int res = SWIG_TypeError;
2847   if (PyFloat_Check(obj)) {
2848     if (val) *val = PyFloat_AsDouble(obj);
2849     return SWIG_OK;
2850   } else if (PyInt_Check(obj)) {
2851     if (val) *val = PyInt_AsLong(obj);
2852     return SWIG_OK;
2853   } else if (PyLong_Check(obj)) {
2854     double v = PyLong_AsDouble(obj);
2855     if (!PyErr_Occurred()) {
2856       if (val) *val = v;
2857       return SWIG_OK;
2858     } else {
2859       PyErr_Clear();
2860     }
2861   }
2862 #ifdef SWIG_PYTHON_CAST_MODE
2863   {
2864     int dispatch = 0;
2865     double d = PyFloat_AsDouble(obj);
2866     if (!PyErr_Occurred()) {
2867       if (val) *val = d;
2868       return SWIG_AddCast(SWIG_OK);
2869     } else {
2870       PyErr_Clear();
2871     }
2872     if (!dispatch) {
2873       long v = PyLong_AsLong(obj);
2874       if (!PyErr_Occurred()) {
2875         if (val) *val = v;
2876         return SWIG_AddCast(SWIG_AddCast(SWIG_OK));
2877       } else {
2878         PyErr_Clear();
2879       }
2880     }
2881   }
2882 #endif
2883   return res;
2884 }
2885
2886
2887 #include <float.h>
2888
2889
2890 #include <math.h>
2891
2892
2893 SWIGINTERNINLINE int
2894 SWIG_CanCastAsInteger(double *d, double min, double max) {
2895   double x = *d;
2896   if ((min <= x && x <= max)) {
2897    double fx = floor(x);
2898    double cx = ceil(x);
2899    double rd =  ((x - fx) < 0.5) ? fx : cx; /* simple rint */
2900    if ((errno == EDOM) || (errno == ERANGE)) {
2901      errno = 0;
2902    } else {
2903      double summ, reps, diff;
2904      if (rd < x) {
2905        diff = x - rd;
2906      } else if (rd > x) {
2907        diff = rd - x;
2908      } else {
2909        return 1;
2910      }
2911      summ = rd + x;
2912      reps = diff/summ;
2913      if (reps < 8*DBL_EPSILON) {
2914        *d = rd;
2915        return 1;
2916      }
2917    }
2918   }
2919   return 0;
2920 }
2921
2922
2923 SWIGINTERN int
2924 SWIG_AsVal_long (PyObject *obj, long* val)
2925 {
2926   if (PyInt_Check(obj)) {
2927     if (val) *val = PyInt_AsLong(obj);
2928     return SWIG_OK;
2929   } else if (PyLong_Check(obj)) {
2930     long v = PyLong_AsLong(obj);
2931     if (!PyErr_Occurred()) {
2932       if (val) *val = v;
2933       return SWIG_OK;
2934     } else {
2935       PyErr_Clear();
2936     }
2937   }
2938 #ifdef SWIG_PYTHON_CAST_MODE
2939   {
2940     int dispatch = 0;
2941     long v = PyInt_AsLong(obj);
2942     if (!PyErr_Occurred()) {
2943       if (val) *val = v;
2944       return SWIG_AddCast(SWIG_OK);
2945     } else {
2946       PyErr_Clear();
2947     }
2948     if (!dispatch) {
2949       double d;
2950       int res = SWIG_AddCast(SWIG_AsVal_double (obj,&d));
2951       if (SWIG_IsOK(res) && SWIG_CanCastAsInteger(&d, LONG_MIN, LONG_MAX)) {
2952         if (val) *val = (long)(d);
2953         return res;
2954       }
2955     }
2956   }
2957 #endif
2958   return SWIG_TypeError;
2959 }
2960
2961
2962 SWIGINTERN int
2963 SWIG_AsVal_int (PyObject * obj, int *val)
2964 {
2965   long v;
2966   int res = SWIG_AsVal_long (obj, &v);
2967   if (SWIG_IsOK(res)) {
2968     if ((v < INT_MIN || v > INT_MAX)) {
2969       return SWIG_OverflowError;
2970     } else {
2971       if (val) *val = (int)(v);
2972     }
2973   }
2974   return res;
2975 }
2976
2977 SWIGINTERN ldb_message_element *new_ldb_message_element(PyObject *set_obj,int flags,char const *name){
2978             return ldb_msg_element_from_pyobject(NULL, set_obj, flags, name);
2979         }
2980 SWIGINTERN int ldb_message_element___len__(ldb_message_element *self){
2981             return self->num_values;
2982         }
2983 SWIGINTERN PyObject *ldb_message_element_get(ldb_message_element *self,int i){
2984             if (i < 0 || i >= self->num_values)
2985                 return Py_None;
2986
2987             return ldb_val_to_py_object(NULL, self, &self->values[i]);
2988         }
2989 SWIGINTERN void delete_ldb_message_element(ldb_message_element *self){ talloc_free(self); }
2990
2991     PyObject *ldb_msg_list_elements(ldb_msg *msg)
2992     {
2993         int i, j = 0;
2994         PyObject *obj = PyList_New(msg->num_elements+(msg->dn != NULL?1:0));
2995         if (msg->dn != NULL) {
2996             PyList_SetItem(obj, j, PyString_FromString("dn"));
2997             j++;
2998         }
2999         for (i = 0; i < msg->num_elements; i++) {
3000             PyList_SetItem(obj, j, PyString_FromString(msg->elements[i].name));
3001             j++;
3002         }
3003         return obj;
3004     }
3005
3006 SWIGINTERN ldb_msg *new_ldb_msg(ldb_dn *dn){
3007             ldb_msg *ret = ldb_msg_new(NULL);
3008             ret->dn = talloc_reference(ret, dn);
3009             return ret;
3010         }
3011 SWIGINTERN void delete_ldb_msg(ldb_msg *self){ talloc_free(self); }
3012 SWIGINTERN void ldb_msg___setitem____SWIG_0(ldb_msg *self,char const *attr_name,ldb_message_element *val){
3013             struct ldb_message_element *el;
3014
3015             ldb_msg_remove_attr(self, attr_name);
3016
3017             el = talloc(self, struct ldb_message_element);
3018             el->name = talloc_strdup(el, attr_name);
3019             el->num_values = val->num_values;
3020             el->values = talloc_reference(el, val->values);
3021
3022             ldb_msg_add(self, el, val->flags);
3023         }
3024 SWIGINTERN void ldb_msg___setitem____SWIG_1(ldb_msg *self,char const *attr_name,PyObject *val){
3025             struct ldb_message_element *el = ldb_msg_element_from_pyobject(NULL,
3026                                                 val, 0, attr_name);
3027             talloc_steal(self, el);
3028             ldb_msg_remove_attr(self, attr_name);
3029             ldb_msg_add(self, el, el->flags);
3030         }
3031 SWIGINTERN unsigned int ldb_msg___len__(ldb_msg *self){ return self->num_elements; }
3032
3033 SWIGINTERNINLINE PyObject*
3034 SWIG_From_unsigned_SS_long  (unsigned long value)
3035 {
3036   return (value > LONG_MAX) ?
3037     PyLong_FromUnsignedLong(value) : PyInt_FromLong((long)(value));
3038 }
3039
3040
3041 SWIGINTERNINLINE PyObject *
3042 SWIG_From_unsigned_SS_int  (unsigned int value)
3043 {
3044   return SWIG_From_unsigned_SS_long  (value);
3045 }
3046
3047 SWIGINTERN PyObject *ldb_msg_keys(ldb_msg *self){
3048             return ldb_msg_list_elements(self);
3049         }
3050 SWIGINTERN PyObject *ldb_msg___iter__(ldb_msg *self){
3051             return PyObject_GetIter(ldb_msg_list_elements(self));
3052         }
3053
3054 static void py_ldb_debug(void *context, enum ldb_debug_level level, const char *fmt, va_list ap) PRINTF_ATTRIBUTE(3, 0);
3055
3056 static void py_ldb_debug(void *context, enum ldb_debug_level level, const char *fmt, va_list ap)
3057 {
3058     char *text;
3059     PyObject *fn = context;
3060
3061     vasprintf(&text, fmt, ap);
3062     PyObject_CallFunction(fn, (char *)"(i,s)", level, text);
3063     free(text);
3064 }
3065
3066
3067     static PyObject *ldb_ldif_to_pyobject(ldb_ldif *ldif)
3068     {
3069         if (ldif == NULL) {
3070             return Py_None;
3071         } else {
3072             return Py_BuildValue((char *)"(iO)", ldif->changetype,
3073                    SWIG_NewPointerObj(ldif->msg, SWIGTYPE_p_ldb_message, 0));
3074         }
3075     }
3076
3077
3078 PyObject *PyExc_LdbError;
3079
3080 SWIGINTERN ldb *new_ldb(){
3081             return ldb_init(NULL, event_context_init(NULL));
3082         }
3083
3084 SWIGINTERN int
3085 SWIG_AsVal_unsigned_SS_long (PyObject *obj, unsigned long *val)
3086 {
3087   if (PyInt_Check(obj)) {
3088     long v = PyInt_AsLong(obj);
3089     if (v >= 0) {
3090       if (val) *val = v;
3091       return SWIG_OK;
3092     } else {
3093       return SWIG_OverflowError;
3094     }
3095   } else if (PyLong_Check(obj)) {
3096     unsigned long v = PyLong_AsUnsignedLong(obj);
3097     if (!PyErr_Occurred()) {
3098       if (val) *val = v;
3099       return SWIG_OK;
3100     } else {
3101       PyErr_Clear();
3102     }
3103   }
3104 #ifdef SWIG_PYTHON_CAST_MODE
3105   {
3106     int dispatch = 0;
3107     unsigned long v = PyLong_AsUnsignedLong(obj);
3108     if (!PyErr_Occurred()) {
3109       if (val) *val = v;
3110       return SWIG_AddCast(SWIG_OK);
3111     } else {
3112       PyErr_Clear();
3113     }
3114     if (!dispatch) {
3115       double d;
3116       int res = SWIG_AddCast(SWIG_AsVal_double (obj,&d));
3117       if (SWIG_IsOK(res) && SWIG_CanCastAsInteger(&d, 0, ULONG_MAX)) {
3118         if (val) *val = (unsigned long)(d);
3119         return res;
3120       }
3121     }
3122   }
3123 #endif
3124   return SWIG_TypeError;
3125 }
3126
3127
3128 SWIGINTERN int
3129 SWIG_AsVal_unsigned_SS_int (PyObject * obj, unsigned int *val)
3130 {
3131   unsigned long v;
3132   int res = SWIG_AsVal_unsigned_SS_long (obj, &v);
3133   if (SWIG_IsOK(res)) {
3134     if ((v > UINT_MAX)) {
3135       return SWIG_OverflowError;
3136     } else {
3137       if (val) *val = (unsigned int)(v);
3138     }
3139   }
3140   return res;
3141 }
3142
3143 SWIGINTERN void delete_ldb(ldb *self){ talloc_free(self); }
3144 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){
3145             int ret;
3146             struct ldb_result *res;
3147             struct ldb_request *req;
3148             res = talloc_zero(mem_ctx, struct ldb_result);
3149             if (!res) {
3150                 return 1;
3151             }
3152
3153             ret = ldb_build_search_req(&req, self, mem_ctx,
3154                            base?base:ldb_get_default_basedn(self),
3155                            scope,
3156                            expression,
3157                            attrs,
3158                            controls,
3159                            res,
3160                            ldb_search_default_callback);
3161
3162             if (ret != 0) {
3163                 talloc_free(res);
3164                 return ret;
3165             }
3166
3167             ldb_set_timeout(self, req, 0); /* use default timeout */
3168
3169             ret = ldb_request(self, req);
3170
3171             if (ret == 0) {
3172                 ret = ldb_wait(req->handle, LDB_WAIT_ALL);
3173             }
3174
3175             talloc_free(req);
3176
3177             *OUT = res;
3178             return ret;
3179         }
3180 SWIGINTERN PyObject *ldb_schema_format_value(ldb *self,char const *element_name,PyObject *val){
3181                 const struct ldb_schema_attribute *a;
3182                 struct ldb_val old_val;
3183                 struct ldb_val new_val;
3184                 TALLOC_CTX *mem_ctx = talloc_new(NULL);
3185                 PyObject *ret;
3186
3187                 old_val.data = PyString_AsString(val);
3188                 old_val.length = PyString_Size(val);
3189
3190                 a = ldb_schema_attribute_by_name(self, element_name);
3191
3192                 if (a == NULL) {
3193                         return Py_None;
3194                 }
3195
3196                 if (a->syntax->ldif_write_fn(self, mem_ctx, &old_val, &new_val) != 0) {
3197                         talloc_free(mem_ctx);
3198                         return Py_None;
3199                  }
3200
3201                 ret = PyString_FromStringAndSize((const char *)new_val.data, new_val.length);
3202
3203                 talloc_free(mem_ctx);
3204
3205                 return ret;
3206         }
3207 SWIGINTERN ldb_error ldb___contains__(ldb *self,ldb_dn *dn,struct ldb_result **result_as_bool){
3208             return ldb_search(self, dn, LDB_SCOPE_BASE, NULL, NULL,
3209                              result_as_bool);
3210         }
3211 SWIGINTERN PyObject *ldb_parse_ldif(ldb *self,char const *s){
3212             PyObject *list = PyList_New(0);
3213             struct ldb_ldif *ldif;
3214             while ((ldif = ldb_ldif_read_string(self, &s)) != NULL) {
3215                 PyList_Append(list, ldb_ldif_to_pyobject(ldif));
3216             }
3217             return PyObject_GetIter(list);
3218         }
3219 SWIGINTERN char *ldb___repr__(ldb *self){
3220             char *ret;
3221             asprintf(&ret, "<ldb connection at 0x%x>", ret);
3222             return ret;
3223         }
3224
3225 static char *timestring(time_t t)
3226 {
3227     char *tresult = ldb_timestring(NULL, t);
3228     char *result = strdup(tresult);
3229     talloc_free(tresult);
3230     return result;
3231 }
3232
3233 SWIGINTERN char const *ldb_module___str__(ldb_module *self){
3234             return self->ops->name;
3235         }
3236 SWIGINTERN char *ldb_module___repr__(ldb_module *self){
3237             char *ret;
3238             asprintf(&ret, "<ldb module '%s'>", self->ops->name);
3239             return ret;
3240         }
3241 SWIGINTERN int ldb_module_search(ldb_module *self,struct ldb_request *req){
3242             return self->ops->search(self, req);
3243         }
3244 SWIGINTERN ldb_error ldb_module_add(ldb_module *self,struct ldb_request *req){
3245             return self->ops->add(self, req);
3246         }
3247 SWIGINTERN ldb_error ldb_module_modify(ldb_module *self,struct ldb_request *req){
3248             return self->ops->modify(self, req);
3249         }
3250 SWIGINTERN ldb_error ldb_module_delete(ldb_module *self,struct ldb_request *req){
3251             return self->ops->del(self, req);
3252         }
3253 SWIGINTERN ldb_error ldb_module_rename(ldb_module *self,struct ldb_request *req){
3254             return self->ops->rename(self, req);
3255         }
3256 SWIGINTERN ldb_error ldb_module_start_transaction(ldb_module *self){
3257             return self->ops->start_transaction(self);
3258         }
3259 SWIGINTERN ldb_error ldb_module_end_transaction(ldb_module *self){
3260             return self->ops->end_transaction(self);
3261         }
3262 SWIGINTERN ldb_error ldb_module_del_transaction(ldb_module *self){
3263             return self->ops->del_transaction(self);
3264         }
3265
3266 int py_module_search(struct ldb_module *mod, struct ldb_request *req)
3267 {
3268     PyObject *py_ldb = mod->private_data;
3269     PyObject *py_result, *py_base, *py_attrs, *py_tree;
3270
3271     py_base = SWIG_NewPointerObj(req->op.search.base, SWIGTYPE_p_ldb_dn, 0);
3272
3273     if (py_base == NULL)
3274         return LDB_ERR_OPERATIONS_ERROR;
3275
3276     py_tree = SWIG_NewPointerObj(req->op.search.tree, SWIGTYPE_p_ldb_parse_tree, 0);
3277
3278     if (py_tree == NULL)
3279         return LDB_ERR_OPERATIONS_ERROR;
3280
3281     if (req->op.search.attrs == NULL) {
3282         py_attrs = Py_None;
3283     } else {
3284         int i, len;
3285         for (len = 0; req->op.search.attrs[len]; len++);
3286         py_attrs = PyList_New(len);
3287         for (i = 0; i < len; i++)
3288             PyList_SetItem(py_attrs, i, PyString_FromString(req->op.search.attrs[i]));
3289     }
3290
3291     py_result = PyObject_CallMethod(py_ldb, "search", "OiOO", py_base, req->op.search.scope, py_tree, py_attrs);
3292
3293     Py_DECREF(py_attrs);
3294     Py_DECREF(py_tree);
3295     Py_DECREF(py_base);
3296
3297     if (py_result == NULL) {
3298         return LDB_ERR_OPERATIONS_ERROR;
3299     }
3300
3301     if (SWIG_ConvertPtr(py_result, &req->op.search.res, SWIGTYPE_p_ldb_result, 0) != 0) {
3302         return LDB_ERR_OPERATIONS_ERROR;
3303     }
3304
3305     Py_DECREF(py_result);
3306
3307     return LDB_SUCCESS;
3308 }
3309
3310 int py_module_add(struct ldb_module *mod, struct ldb_request *req)
3311 {
3312     PyObject *py_ldb = mod->private_data;
3313     PyObject *py_result, *py_msg;
3314
3315     py_msg = SWIG_NewPointerObj(req->op.add.message, SWIGTYPE_p_ldb_message, 0);
3316
3317     if (py_msg == NULL) {
3318         return LDB_ERR_OPERATIONS_ERROR;
3319     }
3320
3321     py_result = PyObject_CallMethod(py_ldb, "add", "O", py_msg);
3322
3323     Py_DECREF(py_msg);
3324
3325     if (py_result == NULL) {
3326         return LDB_ERR_OPERATIONS_ERROR;
3327     }
3328
3329     Py_DECREF(py_result);
3330
3331     return LDB_SUCCESS;
3332 }
3333
3334 int py_module_modify(struct ldb_module *mod, struct ldb_request *req)
3335 {
3336     PyObject *py_ldb = mod->private_data;
3337     PyObject *py_result, *py_msg;
3338
3339     py_msg = SWIG_NewPointerObj(req->op.mod.message, SWIGTYPE_p_ldb_message, 0);
3340
3341     if (py_msg == NULL) {
3342         return LDB_ERR_OPERATIONS_ERROR;
3343     }
3344
3345     py_result = PyObject_CallMethod(py_ldb, "modify", "O", py_msg);
3346
3347     Py_DECREF(py_msg);
3348
3349     if (py_result == NULL) {
3350         return LDB_ERR_OPERATIONS_ERROR;
3351     }
3352
3353     Py_DECREF(py_result);
3354
3355     return LDB_SUCCESS;
3356 }
3357
3358 int py_module_del(struct ldb_module *mod, struct ldb_request *req)
3359 {
3360     PyObject *py_ldb = mod->private_data;
3361     PyObject *py_result, *py_dn;
3362
3363     py_dn = SWIG_NewPointerObj(req->op.del.dn, SWIGTYPE_p_ldb_dn, 0);
3364
3365     if (py_dn == NULL)
3366         return LDB_ERR_OPERATIONS_ERROR;
3367
3368     py_result = PyObject_CallMethod(py_ldb, "delete", "O", py_dn);
3369
3370     if (py_result == NULL) {
3371         return LDB_ERR_OPERATIONS_ERROR;
3372     }
3373
3374     Py_DECREF(py_result);
3375
3376     return LDB_SUCCESS;
3377 }
3378
3379 int py_module_rename(struct ldb_module *mod, struct ldb_request *req)
3380 {
3381     PyObject *py_ldb = mod->private_data;
3382     PyObject *py_result, *py_olddn, *py_newdn;
3383
3384     py_olddn = SWIG_NewPointerObj(req->op.rename.olddn, SWIGTYPE_p_ldb_dn, 0);
3385
3386     if (py_olddn == NULL)
3387         return LDB_ERR_OPERATIONS_ERROR;
3388
3389     py_newdn = SWIG_NewPointerObj(req->op.rename.newdn, SWIGTYPE_p_ldb_dn, 0);
3390
3391     if (py_newdn == NULL)
3392         return LDB_ERR_OPERATIONS_ERROR;
3393
3394     py_result = PyObject_CallMethod(py_ldb, "rename", "OO", py_olddn, py_newdn);
3395
3396     Py_DECREF(py_olddn);
3397     Py_DECREF(py_newdn);
3398
3399     if (py_result == NULL) {
3400         return LDB_ERR_OPERATIONS_ERROR;
3401     }
3402
3403     Py_DECREF(py_result);
3404
3405     return LDB_SUCCESS;
3406 }
3407
3408 int py_module_request(struct ldb_module *mod, struct ldb_request *req)
3409 {
3410     PyObject *py_ldb = mod->private_data;
3411     PyObject *py_result;
3412
3413     py_result = PyObject_CallMethod(py_ldb, "request", "");
3414
3415     return LDB_ERR_OPERATIONS_ERROR;
3416 }
3417
3418 int py_module_extended(struct ldb_module *mod, struct ldb_request *req)
3419 {
3420     PyObject *py_ldb = mod->private_data;
3421     PyObject *py_result;
3422
3423     py_result = PyObject_CallMethod(py_ldb, "extended", "");
3424
3425     return LDB_ERR_OPERATIONS_ERROR;
3426 }
3427
3428 int py_module_start_transaction(struct ldb_module *mod)
3429 {
3430     PyObject *py_ldb = mod->private_data;
3431     PyObject *py_result;
3432
3433     py_result = PyObject_CallMethod(py_ldb, "start_transaction", "");
3434
3435     if (py_result == NULL) {
3436         return LDB_ERR_OPERATIONS_ERROR;
3437     }
3438
3439     Py_DECREF(py_result);
3440
3441     return LDB_SUCCESS;
3442 }
3443
3444 int py_module_end_transaction(struct ldb_module *mod)
3445 {
3446     PyObject *py_ldb = mod->private_data;
3447     PyObject *py_result;
3448
3449     py_result = PyObject_CallMethod(py_ldb, "end_transaction", "");
3450
3451     if (py_result == NULL) {
3452         return LDB_ERR_OPERATIONS_ERROR;
3453     }
3454
3455     Py_DECREF(py_result);
3456
3457     return LDB_SUCCESS;
3458 }
3459
3460 int py_module_del_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, "del_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_wait(struct ldb_handle *mod, enum ldb_wait_type wait_type)
3477 {
3478     PyObject *py_ldb = mod->private_data;
3479     PyObject *py_result;
3480
3481     py_result = PyObject_CallMethod(py_ldb, "wait", "i", wait_type);
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_sequence_number(struct ldb_module *mod, struct ldb_request *req)
3493 {
3494     PyObject *py_ldb = mod->private_data;
3495     PyObject *py_result;
3496     int ret;
3497
3498     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);
3499
3500     if (py_result == NULL) {
3501         return LDB_ERR_OPERATIONS_ERROR;
3502     }
3503
3504     ret = PyInt_AsLong(py_result);
3505
3506     Py_DECREF(py_result);
3507
3508     return ret;
3509 }
3510
3511 static int py_module_destructor(void *_mod)
3512 {
3513     struct ldb_module *mod = _mod;
3514     Py_DECREF((PyObject *)mod->private_data);
3515     return 0;
3516 }
3517
3518 int py_module_init (struct ldb_module *mod)
3519 {
3520     PyObject *py_class = mod->ops->private_data;
3521     PyObject *py_result, *py_next, *py_ldb;
3522
3523     py_ldb = SWIG_NewPointerObj(mod->ldb, SWIGTYPE_p_ldb_context, 0);
3524
3525     if (py_ldb == NULL)
3526         return LDB_ERR_OPERATIONS_ERROR;
3527
3528     py_next = SWIG_NewPointerObj(mod->next, SWIGTYPE_p_ldb_module, 0);
3529
3530     if (py_next == NULL)
3531         return LDB_ERR_OPERATIONS_ERROR;
3532
3533     py_result = PyObject_CallFunction(py_class, "OO", py_ldb, py_next);
3534
3535     if (py_result == NULL) {
3536         return LDB_ERR_OPERATIONS_ERROR;
3537     }
3538
3539     mod->private_data = py_result;
3540
3541     talloc_set_destructor (mod, py_module_destructor);
3542
3543     return ldb_next_init(mod);
3544 }
3545
3546 #ifdef __cplusplus
3547 extern "C" {
3548 #endif
3549 SWIGINTERN PyObject *_wrap_ldb_val_to_py_object(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
3550   PyObject *resultobj = 0;
3551   struct ldb_context *arg1 = (struct ldb_context *) 0 ;
3552   struct ldb_message_element *arg2 = (struct ldb_message_element *) 0 ;
3553   struct ldb_val *arg3 = (struct ldb_val *) 0 ;
3554   void *argp1 = 0 ;
3555   int res1 = 0 ;
3556   void *argp2 = 0 ;
3557   int res2 = 0 ;
3558   void *argp3 = 0 ;
3559   int res3 = 0 ;
3560   PyObject * obj0 = 0 ;
3561   PyObject * obj1 = 0 ;
3562   PyObject * obj2 = 0 ;
3563   char *  kwnames[] = {
3564     (char *) "ldb_ctx",(char *) "el",(char *) "val", NULL
3565   };
3566   PyObject *result = 0 ;
3567
3568   if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ldb_val_to_py_object",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
3569   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ldb_context, 0 |  0 );
3570   if (!SWIG_IsOK(res1)) {
3571     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ldb_val_to_py_object" "', argument " "1"" of type '" "struct ldb_context *""'");
3572   }
3573   arg1 = (struct ldb_context *)(argp1);
3574   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_ldb_message_element, 0 |  0 );
3575   if (!SWIG_IsOK(res2)) {
3576     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ldb_val_to_py_object" "', argument " "2"" of type '" "struct ldb_message_element *""'");
3577   }
3578   arg2 = (struct ldb_message_element *)(argp2);
3579   res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_ldb_val, 0 |  0 );
3580   if (!SWIG_IsOK(res3)) {
3581     SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ldb_val_to_py_object" "', argument " "3"" of type '" "struct ldb_val *""'");
3582   }
3583   arg3 = (struct ldb_val *)(argp3);
3584   if (arg1 == NULL)
3585   SWIG_exception(SWIG_ValueError,
3586     "ldb context must be non-NULL");
3587   result = (PyObject *)ldb_val_to_py_object(arg1,arg2,arg3);
3588   resultobj = result;
3589   return resultobj;
3590 fail:
3591   return NULL;
3592 }
3593
3594
3595 SWIGINTERN PyObject *_wrap_new_Dn(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
3596   PyObject *resultobj = 0;
3597   ldb *arg1 = (ldb *) 0 ;
3598   char *arg2 = (char *) 0 ;
3599   void *argp1 = 0 ;
3600   int res1 = 0 ;
3601   int res2 ;
3602   char *buf2 = 0 ;
3603   int alloc2 = 0 ;
3604   PyObject * obj0 = 0 ;
3605   PyObject * obj1 = 0 ;
3606   char *  kwnames[] = {
3607     (char *) "ldb_ctx",(char *) "str", NULL
3608   };
3609   ldb_dn *result = 0 ;
3610
3611   if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_Dn",kwnames,&obj0,&obj1)) SWIG_fail;
3612   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ldb_context, 0 |  0 );
3613   if (!SWIG_IsOK(res1)) {
3614     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Dn" "', argument " "1"" of type '" "ldb *""'");
3615   }
3616   arg1 = (ldb *)(argp1);
3617   res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
3618   if (!SWIG_IsOK(res2)) {
3619     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_Dn" "', argument " "2"" of type '" "char const *""'");
3620   }
3621   arg2 = (char *)(buf2);
3622   if (arg1 == NULL)
3623   SWIG_exception(SWIG_ValueError,
3624     "ldb context must be non-NULL");
3625   result = (ldb_dn *)new_ldb_dn(arg1,(char const *)arg2);
3626   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ldb_dn, SWIG_POINTER_NEW |  0 );
3627   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
3628   return resultobj;
3629 fail:
3630   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
3631   return NULL;
3632 }
3633
3634
3635 SWIGINTERN PyObject *_wrap_delete_Dn(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3636   PyObject *resultobj = 0;
3637   ldb_dn *arg1 = (ldb_dn *) 0 ;
3638   void *argp1 = 0 ;
3639   int res1 = 0 ;
3640   PyObject *swig_obj[1] ;
3641
3642   if (!args) SWIG_fail;
3643   swig_obj[0] = args;
3644   res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ldb_dn, SWIG_POINTER_DISOWN |  0 );
3645   if (!SWIG_IsOK(res1)) {
3646     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Dn" "', argument " "1"" of type '" "ldb_dn *""'");
3647   }
3648   arg1 = (ldb_dn *)(argp1);
3649   delete_ldb_dn(arg1);
3650   resultobj = SWIG_Py_Void();
3651   return resultobj;
3652 fail:
3653   return NULL;
3654 }
3655
3656
3657 SWIGINTERN PyObject *_wrap_Dn_validate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3658   PyObject *resultobj = 0;
3659   ldb_dn *arg1 = (ldb_dn *) 0 ;
3660   void *argp1 = 0 ;
3661   int res1 = 0 ;
3662   PyObject *swig_obj[1] ;
3663   bool result;
3664
3665   if (!args) SWIG_fail;
3666   swig_obj[0] = args;
3667   res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ldb_dn, 0 |  0 );
3668   if (!SWIG_IsOK(res1)) {
3669     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dn_validate" "', argument " "1"" of type '" "ldb_dn *""'");
3670   }
3671   arg1 = (ldb_dn *)(argp1);
3672   result = (bool)ldb_dn_validate(arg1);
3673   resultobj = SWIG_From_bool((bool)(result));
3674   return resultobj;
3675 fail:
3676   return NULL;
3677 }
3678
3679
3680 SWIGINTERN PyObject *_wrap_Dn_get_casefold(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3681   PyObject *resultobj = 0;
3682   ldb_dn *arg1 = (ldb_dn *) 0 ;
3683   void *argp1 = 0 ;
3684   int res1 = 0 ;
3685   PyObject *swig_obj[1] ;
3686   char *result = 0 ;
3687
3688   if (!args) SWIG_fail;
3689   swig_obj[0] = args;
3690   res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ldb_dn, 0 |  0 );
3691   if (!SWIG_IsOK(res1)) {
3692     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dn_get_casefold" "', argument " "1"" of type '" "ldb_dn *""'");
3693   }
3694   arg1 = (ldb_dn *)(argp1);
3695   result = (char *)ldb_dn_get_casefold(arg1);
3696   resultobj = SWIG_FromCharPtr((const char *)result);
3697   return resultobj;
3698 fail:
3699   return NULL;
3700 }
3701
3702
3703 SWIGINTERN PyObject *_wrap_Dn___str__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3704   PyObject *resultobj = 0;
3705   ldb_dn *arg1 = (ldb_dn *) 0 ;
3706   void *argp1 = 0 ;
3707   int res1 = 0 ;
3708   PyObject *swig_obj[1] ;
3709   char *result = 0 ;
3710
3711   if (!args) SWIG_fail;
3712   swig_obj[0] = args;
3713   res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ldb_dn, 0 |  0 );
3714   if (!SWIG_IsOK(res1)) {
3715     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dn___str__" "', argument " "1"" of type '" "ldb_dn *""'");
3716   }
3717   arg1 = (ldb_dn *)(argp1);
3718   result = (char *)ldb_dn_get_linearized(arg1);
3719   resultobj = SWIG_FromCharPtr((const char *)result);
3720   return resultobj;
3721 fail:
3722   return NULL;
3723 }
3724
3725
3726 SWIGINTERN PyObject *_wrap_Dn_parent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3727   PyObject *resultobj = 0;
3728   ldb_dn *arg1 = (ldb_dn *) 0 ;
3729   void *argp1 = 0 ;
3730   int res1 = 0 ;
3731   PyObject *swig_obj[1] ;
3732   ldb_dn *result = 0 ;
3733
3734   if (!args) SWIG_fail;
3735   swig_obj[0] = args;
3736   res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ldb_dn, 0 |  0 );
3737   if (!SWIG_IsOK(res1)) {
3738     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dn_parent" "', argument " "1"" of type '" "ldb_dn *""'");
3739   }
3740   arg1 = (ldb_dn *)(argp1);
3741   result = (ldb_dn *)ldb_dn_parent(arg1);
3742   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ldb_dn, 0 |  0 );
3743   return resultobj;
3744 fail:
3745   return NULL;
3746 }
3747
3748
3749 SWIGINTERN PyObject *_wrap_Dn___cmp__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
3750   PyObject *resultobj = 0;
3751   ldb_dn *arg1 = (ldb_dn *) 0 ;
3752   ldb_dn *arg2 = (ldb_dn *) 0 ;
3753   void *argp1 = 0 ;
3754   int res1 = 0 ;
3755   void *argp2 = 0 ;
3756   int res2 = 0 ;
3757   PyObject * obj0 = 0 ;
3758   PyObject * obj1 = 0 ;
3759   char *  kwnames[] = {
3760     (char *) "self",(char *) "other", NULL
3761   };
3762   int result;
3763
3764   if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Dn___cmp__",kwnames,&obj0,&obj1)) SWIG_fail;
3765   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ldb_dn, 0 |  0 );
3766   if (!SWIG_IsOK(res1)) {
3767     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dn___cmp__" "', argument " "1"" of type '" "ldb_dn *""'");
3768   }
3769   arg1 = (ldb_dn *)(argp1);
3770   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_ldb_dn, 0 |  0 );
3771   if (!SWIG_IsOK(res2)) {
3772     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dn___cmp__" "', argument " "2"" of type '" "ldb_dn *""'");
3773   }
3774   arg2 = (ldb_dn *)(argp2);
3775   result = (int)ldb_dn_compare(arg1,arg2);
3776   resultobj = SWIG_From_int((int)(result));
3777   return resultobj;
3778 fail:
3779   return NULL;
3780 }
3781
3782
3783 SWIGINTERN PyObject *_wrap_Dn_is_valid(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3784   PyObject *resultobj = 0;
3785   ldb_dn *arg1 = (ldb_dn *) 0 ;
3786   void *argp1 = 0 ;
3787   int res1 = 0 ;
3788   PyObject *swig_obj[1] ;
3789   bool result;
3790
3791   if (!args) SWIG_fail;
3792   swig_obj[0] = args;
3793   res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ldb_dn, 0 |  0 );
3794   if (!SWIG_IsOK(res1)) {
3795     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dn_is_valid" "', argument " "1"" of type '" "ldb_dn *""'");
3796   }
3797   arg1 = (ldb_dn *)(argp1);
3798   result = (bool)ldb_dn_is_valid(arg1);
3799   resultobj = SWIG_From_bool((bool)(result));
3800   return resultobj;
3801 fail:
3802   return NULL;
3803 }
3804
3805
3806 SWIGINTERN PyObject *_wrap_Dn_is_special(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3807   PyObject *resultobj = 0;
3808   ldb_dn *arg1 = (ldb_dn *) 0 ;
3809   void *argp1 = 0 ;
3810   int res1 = 0 ;
3811   PyObject *swig_obj[1] ;
3812   bool result;
3813
3814   if (!args) SWIG_fail;
3815   swig_obj[0] = args;
3816   res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ldb_dn, 0 |  0 );
3817   if (!SWIG_IsOK(res1)) {
3818     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dn_is_special" "', argument " "1"" of type '" "ldb_dn *""'");
3819   }
3820   arg1 = (ldb_dn *)(argp1);
3821   result = (bool)ldb_dn_is_special(arg1);
3822   resultobj = SWIG_From_bool((bool)(result));
3823   return resultobj;
3824 fail:
3825   return NULL;
3826 }
3827
3828
3829 SWIGINTERN PyObject *_wrap_Dn_is_null(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3830   PyObject *resultobj = 0;
3831   ldb_dn *arg1 = (ldb_dn *) 0 ;
3832   void *argp1 = 0 ;
3833   int res1 = 0 ;
3834   PyObject *swig_obj[1] ;
3835   bool result;
3836
3837   if (!args) SWIG_fail;
3838   swig_obj[0] = args;
3839   res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ldb_dn, 0 |  0 );
3840   if (!SWIG_IsOK(res1)) {
3841     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dn_is_null" "', argument " "1"" of type '" "ldb_dn *""'");
3842   }
3843   arg1 = (ldb_dn *)(argp1);
3844   result = (bool)ldb_dn_is_null(arg1);
3845   resultobj = SWIG_From_bool((bool)(result));
3846   return resultobj;
3847 fail:
3848   return NULL;
3849 }
3850
3851
3852 SWIGINTERN PyObject *_wrap_Dn_check_special(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
3853   PyObject *resultobj = 0;
3854   ldb_dn *arg1 = (ldb_dn *) 0 ;
3855   char *arg2 = (char *) 0 ;
3856   void *argp1 = 0 ;
3857   int res1 = 0 ;
3858   int res2 ;
3859   char *buf2 = 0 ;
3860   int alloc2 = 0 ;
3861   PyObject * obj0 = 0 ;
3862   PyObject * obj1 = 0 ;
3863   char *  kwnames[] = {
3864     (char *) "self",(char *) "name", NULL
3865   };
3866   bool result;
3867
3868   if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Dn_check_special",kwnames,&obj0,&obj1)) SWIG_fail;
3869   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ldb_dn, 0 |  0 );
3870   if (!SWIG_IsOK(res1)) {
3871     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dn_check_special" "', argument " "1"" of type '" "ldb_dn *""'");
3872   }
3873   arg1 = (ldb_dn *)(argp1);
3874   res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
3875   if (!SWIG_IsOK(res2)) {
3876     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dn_check_special" "', argument " "2"" of type '" "char const *""'");
3877   }
3878   arg2 = (char *)(buf2);
3879   result = (bool)ldb_dn_check_special(arg1,(char const *)arg2);
3880   resultobj = SWIG_From_bool((bool)(result));
3881   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
3882   return resultobj;
3883 fail:
3884   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
3885   return NULL;
3886 }
3887
3888
3889 SWIGINTERN PyObject *_wrap_Dn___len__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3890   PyObject *resultobj = 0;
3891   ldb_dn *arg1 = (ldb_dn *) 0 ;
3892   void *argp1 = 0 ;
3893   int res1 = 0 ;
3894   PyObject *swig_obj[1] ;
3895   int result;
3896
3897   if (!args) SWIG_fail;
3898   swig_obj[0] = args;
3899   res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ldb_dn, 0 |  0 );
3900   if (!SWIG_IsOK(res1)) {
3901     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dn___len__" "', argument " "1"" of type '" "ldb_dn *""'");
3902   }
3903   arg1 = (ldb_dn *)(argp1);
3904   result = (int)ldb_dn_get_comp_num(arg1);
3905   resultobj = SWIG_From_int((int)(result));
3906   return resultobj;
3907 fail:
3908   return NULL;
3909 }
3910
3911
3912 SWIGINTERN PyObject *_wrap_Dn_add_child(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
3913   PyObject *resultobj = 0;
3914   ldb_dn *arg1 = (ldb_dn *) 0 ;
3915   ldb_dn *arg2 = (ldb_dn *) 0 ;
3916   void *argp1 = 0 ;
3917   int res1 = 0 ;
3918   void *argp2 = 0 ;
3919   int res2 = 0 ;
3920   PyObject * obj0 = 0 ;
3921   PyObject * obj1 = 0 ;
3922   char *  kwnames[] = {
3923     (char *) "self",(char *) "child", NULL
3924   };
3925   bool result;
3926
3927   if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Dn_add_child",kwnames,&obj0,&obj1)) SWIG_fail;
3928   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ldb_dn, 0 |  0 );
3929   if (!SWIG_IsOK(res1)) {
3930     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dn_add_child" "', argument " "1"" of type '" "ldb_dn *""'");
3931   }
3932   arg1 = (ldb_dn *)(argp1);
3933   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_ldb_dn, 0 |  0 );
3934   if (!SWIG_IsOK(res2)) {
3935     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dn_add_child" "', argument " "2"" of type '" "ldb_dn *""'");
3936   }
3937   arg2 = (ldb_dn *)(argp2);
3938   result = (bool)ldb_dn_add_child(arg1,arg2);
3939   resultobj = SWIG_From_bool((bool)(result));
3940   return resultobj;
3941 fail:
3942   return NULL;
3943 }
3944
3945
3946 SWIGINTERN PyObject *_wrap_Dn_add_base(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
3947   PyObject *resultobj = 0;
3948   ldb_dn *arg1 = (ldb_dn *) 0 ;
3949   ldb_dn *arg2 = (ldb_dn *) 0 ;
3950   void *argp1 = 0 ;
3951   int res1 = 0 ;
3952   void *argp2 = 0 ;
3953   int res2 = 0 ;
3954   PyObject * obj0 = 0 ;
3955   PyObject * obj1 = 0 ;
3956   char *  kwnames[] = {
3957     (char *) "self",(char *) "base", NULL
3958   };
3959   bool result;
3960
3961   if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Dn_add_base",kwnames,&obj0,&obj1)) SWIG_fail;
3962   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ldb_dn, 0 |  0 );
3963   if (!SWIG_IsOK(res1)) {
3964     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dn_add_base" "', argument " "1"" of type '" "ldb_dn *""'");
3965   }
3966   arg1 = (ldb_dn *)(argp1);
3967   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_ldb_dn, 0 |  0 );
3968   if (!SWIG_IsOK(res2)) {
3969     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dn_add_base" "', argument " "2"" of type '" "ldb_dn *""'");
3970   }
3971   arg2 = (ldb_dn *)(argp2);
3972   result = (bool)ldb_dn_add_base(arg1,arg2);
3973   resultobj = SWIG_From_bool((bool)(result));
3974   return resultobj;
3975 fail:
3976   return NULL;
3977 }
3978
3979
3980 SWIGINTERN PyObject *_wrap_Dn_canonical_str(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3981   PyObject *resultobj = 0;
3982   ldb_dn *arg1 = (ldb_dn *) 0 ;
3983   void *argp1 = 0 ;
3984   int res1 = 0 ;
3985   PyObject *swig_obj[1] ;
3986   char *result = 0 ;
3987
3988   if (!args) SWIG_fail;
3989   swig_obj[0] = args;
3990   res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ldb_dn, 0 |  0 );
3991   if (!SWIG_IsOK(res1)) {
3992     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dn_canonical_str" "', argument " "1"" of type '" "ldb_dn *""'");
3993   }
3994   arg1 = (ldb_dn *)(argp1);
3995   result = (char *)ldb_dn_canonical_str(arg1);
3996   resultobj = SWIG_FromCharPtr((const char *)result);
3997   return resultobj;
3998 fail:
3999   return NULL;
4000 }
4001
4002
4003 SWIGINTERN PyObject *_wrap_Dn_canonical_ex_str(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4004   PyObject *resultobj = 0;
4005   ldb_dn *arg1 = (ldb_dn *) 0 ;
4006   void *argp1 = 0 ;
4007   int res1 = 0 ;
4008   PyObject *swig_obj[1] ;
4009   char *result = 0 ;
4010
4011   if (!args) SWIG_fail;
4012   swig_obj[0] = args;
4013   res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ldb_dn, 0 |  0 );
4014   if (!SWIG_IsOK(res1)) {
4015     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dn_canonical_ex_str" "', argument " "1"" of type '" "ldb_dn *""'");
4016   }
4017   arg1 = (ldb_dn *)(argp1);
4018   result = (char *)ldb_dn_canonical_ex_str(arg1);
4019   resultobj = SWIG_FromCharPtr((const char *)result);
4020   return resultobj;
4021 fail:
4022   return NULL;
4023 }
4024
4025
4026 SWIGINTERN PyObject *_wrap_Dn___repr__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4027   PyObject *resultobj = 0;
4028   ldb_dn *arg1 = (ldb_dn *) 0 ;
4029   void *argp1 = 0 ;
4030   int res1 = 0 ;
4031   PyObject *swig_obj[1] ;
4032   char *result = 0 ;
4033
4034   if (!args) SWIG_fail;
4035   swig_obj[0] = args;
4036   res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ldb_dn, 0 |  0 );
4037   if (!SWIG_IsOK(res1)) {
4038     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dn___repr__" "', argument " "1"" of type '" "ldb_dn *""'");
4039   }
4040   arg1 = (ldb_dn *)(argp1);
4041   result = (char *)ldb_dn___repr__(arg1);
4042   resultobj = SWIG_FromCharPtr((const char *)result);
4043   return resultobj;
4044 fail:
4045   return NULL;
4046 }
4047
4048
4049 SWIGINTERN PyObject *_wrap_Dn___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4050   PyObject *resultobj = 0;
4051   ldb_dn *arg1 = (ldb_dn *) 0 ;
4052   ldb_dn *arg2 = (ldb_dn *) 0 ;
4053   void *argp1 = 0 ;
4054   int res1 = 0 ;
4055   void *argp2 = 0 ;
4056   int res2 = 0 ;
4057   PyObject * obj0 = 0 ;
4058   PyObject * obj1 = 0 ;
4059   char *  kwnames[] = {
4060     (char *) "self",(char *) "other", NULL
4061   };
4062   ldb_dn *result = 0 ;
4063
4064   if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Dn___add__",kwnames,&obj0,&obj1)) SWIG_fail;
4065   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ldb_dn, 0 |  0 );
4066   if (!SWIG_IsOK(res1)) {
4067     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dn___add__" "', argument " "1"" of type '" "ldb_dn *""'");
4068   }
4069   arg1 = (ldb_dn *)(argp1);
4070   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_ldb_dn, 0 |  0 );
4071   if (!SWIG_IsOK(res2)) {
4072     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dn___add__" "', argument " "2"" of type '" "ldb_dn *""'");
4073   }
4074   arg2 = (ldb_dn *)(argp2);
4075   result = (ldb_dn *)ldb_dn___add__(arg1,arg2);
4076   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ldb_dn, 0 |  0 );
4077   return resultobj;
4078 fail:
4079   return NULL;
4080 }
4081
4082
4083 SWIGINTERN PyObject *Dn_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4084   PyObject *obj;
4085   if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
4086   SWIG_TypeNewClientData(SWIGTYPE_p_ldb_dn, SWIG_NewClientData(obj));
4087   return SWIG_Py_Void();
4088 }
4089
4090 SWIGINTERN PyObject *Dn_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4091   return SWIG_Python_InitShadowInstance(args);
4092 }
4093
4094 SWIGINTERN PyObject *_wrap_MessageElement___cmp__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4095   PyObject *resultobj = 0;
4096   ldb_message_element *arg1 = (ldb_message_element *) 0 ;
4097   ldb_message_element *arg2 = (ldb_message_element *) 0 ;
4098   void *argp1 = 0 ;
4099   int res1 = 0 ;
4100   void *argp2 = 0 ;
4101   int res2 = 0 ;
4102   PyObject * obj0 = 0 ;
4103   PyObject * obj1 = 0 ;
4104   char *  kwnames[] = {
4105     (char *) "self",(char *) "other", NULL
4106   };
4107   int result;
4108
4109   if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MessageElement___cmp__",kwnames,&obj0,&obj1)) SWIG_fail;
4110   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ldb_message_element, 0 |  0 );
4111   if (!SWIG_IsOK(res1)) {
4112     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MessageElement___cmp__" "', argument " "1"" of type '" "ldb_message_element *""'");
4113   }
4114   arg1 = (ldb_message_element *)(argp1);
4115   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_ldb_message_element, 0 |  0 );
4116   if (!SWIG_IsOK(res2)) {
4117     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MessageElement___cmp__" "', argument " "2"" of type '" "ldb_message_element *""'");
4118   }
4119   arg2 = (ldb_message_element *)(argp2);
4120   result = (int)ldb_message_element___cmp__(arg1,arg2);
4121   resultobj = SWIG_From_int((int)(result));
4122   return resultobj;
4123 fail:
4124   return NULL;
4125 }
4126
4127
4128 SWIGINTERN PyObject *_wrap_MessageElement___iter__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4129   PyObject *resultobj = 0;
4130   ldb_message_element *arg1 = (ldb_message_element *) 0 ;
4131   void *argp1 = 0 ;
4132   int res1 = 0 ;
4133   PyObject *swig_obj[1] ;
4134   PyObject *result = 0 ;
4135
4136   if (!args) SWIG_fail;
4137   swig_obj[0] = args;
4138   res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ldb_message_element, 0 |  0 );
4139   if (!SWIG_IsOK(res1)) {
4140     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MessageElement___iter__" "', argument " "1"" of type '" "ldb_message_element *""'");
4141   }
4142   arg1 = (ldb_message_element *)(argp1);
4143   result = (PyObject *)ldb_message_element___iter__(arg1);
4144   resultobj = result;
4145   return resultobj;
4146 fail:
4147   return NULL;
4148 }
4149
4150
4151 SWIGINTERN PyObject *_wrap_MessageElement___set__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4152   PyObject *resultobj = 0;
4153   ldb_message_element *arg1 = (ldb_message_element *) 0 ;
4154   void *argp1 = 0 ;
4155   int res1 = 0 ;
4156   PyObject *swig_obj[1] ;
4157   PyObject *result = 0 ;
4158
4159   if (!args) SWIG_fail;
4160   swig_obj[0] = args;
4161   res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ldb_message_element, 0 |  0 );
4162   if (!SWIG_IsOK(res1)) {
4163     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MessageElement___set__" "', argument " "1"" of type '" "ldb_message_element *""'");
4164   }
4165   arg1 = (ldb_message_element *)(argp1);
4166   result = (PyObject *)ldb_message_element___set__(arg1);
4167   resultobj = result;
4168   return resultobj;
4169 fail:
4170   return NULL;
4171 }
4172
4173
4174 SWIGINTERN PyObject *_wrap_new_MessageElement(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4175   PyObject *resultobj = 0;
4176   PyObject *arg1 = (PyObject *) 0 ;
4177   int arg2 = (int) 0 ;
4178   char *arg3 = (char *) NULL ;
4179   int val2 ;
4180   int ecode2 = 0 ;
4181   int res3 ;
4182   char *buf3 = 0 ;
4183   int alloc3 = 0 ;
4184   PyObject * obj0 = 0 ;
4185   PyObject * obj1 = 0 ;
4186   PyObject * obj2 = 0 ;
4187   char *  kwnames[] = {
4188     (char *) "set_obj",(char *) "flags",(char *) "name", NULL
4189   };
4190   ldb_message_element *result = 0 ;
4191
4192   if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:new_MessageElement",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
4193   arg1 = obj0;
4194   if (obj1) {
4195     ecode2 = SWIG_AsVal_int(obj1, &val2);
4196     if (!SWIG_IsOK(ecode2)) {
4197       SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_MessageElement" "', argument " "2"" of type '" "int""'");
4198     }
4199     arg2 = (int)(val2);
4200   }
4201   if (obj2) {
4202     res3 = SWIG_AsCharPtrAndSize(obj2, &buf3, NULL, &alloc3);
4203     if (!SWIG_IsOK(res3)) {
4204       SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_MessageElement" "', argument " "3"" of type '" "char const *""'");
4205     }
4206     arg3 = (char *)(buf3);
4207   }
4208   result = (ldb_message_element *)new_ldb_message_element(arg1,arg2,(char const *)arg3);
4209   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ldb_message_element, SWIG_POINTER_NEW |  0 );
4210   if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
4211   return resultobj;
4212 fail:
4213   if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
4214   return NULL;
4215 }
4216
4217
4218 SWIGINTERN PyObject *_wrap_MessageElement___len__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4219   PyObject *resultobj = 0;
4220   ldb_message_element *arg1 = (ldb_message_element *) 0 ;
4221   void *argp1 = 0 ;
4222   int res1 = 0 ;
4223   PyObject *swig_obj[1] ;
4224   int result;
4225
4226   if (!args) SWIG_fail;
4227   swig_obj[0] = args;
4228   res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ldb_message_element, 0 |  0 );
4229   if (!SWIG_IsOK(res1)) {
4230     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MessageElement___len__" "', argument " "1"" of type '" "ldb_message_element *""'");
4231   }
4232   arg1 = (ldb_message_element *)(argp1);
4233   result = (int)ldb_message_element___len__(arg1);
4234   resultobj = SWIG_From_int((int)(result));
4235   return resultobj;
4236 fail:
4237   return NULL;
4238 }
4239
4240
4241 SWIGINTERN PyObject *_wrap_MessageElement_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4242   PyObject *resultobj = 0;
4243   ldb_message_element *arg1 = (ldb_message_element *) 0 ;
4244   int arg2 ;
4245   void *argp1 = 0 ;
4246   int res1 = 0 ;
4247   int val2 ;
4248   int ecode2 = 0 ;
4249   PyObject * obj0 = 0 ;
4250   PyObject * obj1 = 0 ;
4251   char *  kwnames[] = {
4252     (char *) "self",(char *) "i", NULL
4253   };
4254   PyObject *result = 0 ;
4255
4256   if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MessageElement_get",kwnames,&obj0,&obj1)) SWIG_fail;
4257   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ldb_message_element, 0 |  0 );
4258   if (!SWIG_IsOK(res1)) {
4259     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MessageElement_get" "', argument " "1"" of type '" "ldb_message_element *""'");
4260   }
4261   arg1 = (ldb_message_element *)(argp1);
4262   ecode2 = SWIG_AsVal_int(obj1, &val2);
4263   if (!SWIG_IsOK(ecode2)) {
4264     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MessageElement_get" "', argument " "2"" of type '" "int""'");
4265   }
4266   arg2 = (int)(val2);
4267   result = (PyObject *)ldb_message_element_get(arg1,arg2);
4268   resultobj = result;
4269   return resultobj;
4270 fail:
4271   return NULL;
4272 }
4273
4274
4275 SWIGINTERN PyObject *_wrap_delete_MessageElement(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4276   PyObject *resultobj = 0;
4277   ldb_message_element *arg1 = (ldb_message_element *) 0 ;
4278   void *argp1 = 0 ;
4279   int res1 = 0 ;
4280   PyObject *swig_obj[1] ;
4281
4282   if (!args) SWIG_fail;
4283   swig_obj[0] = args;
4284   res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ldb_message_element, SWIG_POINTER_DISOWN |  0 );
4285   if (!SWIG_IsOK(res1)) {
4286     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MessageElement" "', argument " "1"" of type '" "ldb_message_element *""'");
4287   }
4288   arg1 = (ldb_message_element *)(argp1);
4289   delete_ldb_message_element(arg1);
4290   resultobj = SWIG_Py_Void();
4291   return resultobj;
4292 fail:
4293   return NULL;
4294 }
4295
4296
4297 SWIGINTERN PyObject *MessageElement_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4298   PyObject *obj;
4299   if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
4300   SWIG_TypeNewClientData(SWIGTYPE_p_ldb_message_element, SWIG_NewClientData(obj));
4301   return SWIG_Py_Void();
4302 }
4303
4304 SWIGINTERN PyObject *MessageElement_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4305   return SWIG_Python_InitShadowInstance(args);
4306 }
4307
4308 SWIGINTERN PyObject *_wrap_ldb_msg_list_elements(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4309   PyObject *resultobj = 0;
4310   ldb_msg *arg1 = (ldb_msg *) 0 ;
4311   void *argp1 = 0 ;
4312   int res1 = 0 ;
4313   PyObject * obj0 = 0 ;
4314   char *  kwnames[] = {
4315     (char *) "msg", NULL
4316   };
4317   PyObject *result = 0 ;
4318
4319   if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ldb_msg_list_elements",kwnames,&obj0)) SWIG_fail;
4320   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ldb_message, 0 |  0 );
4321   if (!SWIG_IsOK(res1)) {
4322     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ldb_msg_list_elements" "', argument " "1"" of type '" "ldb_msg *""'");
4323   }
4324   arg1 = (ldb_msg *)(argp1);
4325   if (arg1 == NULL)
4326   SWIG_exception(SWIG_ValueError,
4327     "Message can not be None");
4328   result = (PyObject *)ldb_msg_list_elements(arg1);
4329   resultobj = result;
4330   return resultobj;
4331 fail:
4332   return NULL;
4333 }
4334
4335
4336 SWIGINTERN PyObject *_wrap_Message_dn_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4337   PyObject *resultobj = 0;
4338   ldb_msg *arg1 = (ldb_msg *) 0 ;
4339   ldb_dn *arg2 = (ldb_dn *) 0 ;
4340   void *argp1 = 0 ;
4341   int res1 = 0 ;
4342   void *argp2 = 0 ;
4343   int res2 = 0 ;
4344   PyObject *swig_obj[2] ;
4345
4346   if (!SWIG_Python_UnpackTuple(args,"Message_dn_set",2,2,swig_obj)) SWIG_fail;
4347   res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ldb_message, 0 |  0 );
4348   if (!SWIG_IsOK(res1)) {
4349     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Message_dn_set" "', argument " "1"" of type '" "ldb_msg *""'");
4350   }
4351   arg1 = (ldb_msg *)(argp1);
4352   res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_ldb_dn, SWIG_POINTER_DISOWN |  0 );
4353   if (!SWIG_IsOK(res2)) {
4354     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Message_dn_set" "', argument " "2"" of type '" "ldb_dn *""'");
4355   }
4356   arg2 = (ldb_dn *)(argp2);
4357   if (arg1 == NULL)
4358   SWIG_exception(SWIG_ValueError,
4359     "Message can not be None");
4360   if (arg1) (arg1)->dn = arg2;
4361   resultobj = SWIG_Py_Void();
4362   return resultobj;
4363 fail:
4364   return NULL;
4365 }
4366
4367
4368 SWIGINTERN PyObject *_wrap_Message_dn_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4369   PyObject *resultobj = 0;
4370   ldb_msg *arg1 = (ldb_msg *) 0 ;
4371   void *argp1 = 0 ;
4372   int res1 = 0 ;
4373   PyObject *swig_obj[1] ;
4374   ldb_dn *result = 0 ;
4375
4376   if (!args) SWIG_fail;
4377   swig_obj[0] = args;
4378   res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ldb_message, 0 |  0 );
4379   if (!SWIG_IsOK(res1)) {
4380     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Message_dn_get" "', argument " "1"" of type '" "ldb_msg *""'");
4381   }
4382   arg1 = (ldb_msg *)(argp1);
4383   if (arg1 == NULL)
4384   SWIG_exception(SWIG_ValueError,
4385     "Message can not be None");
4386   result = (ldb_dn *) ((arg1)->dn);
4387   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ldb_dn, 0 |  0 );
4388   return resultobj;
4389 fail:
4390   return NULL;
4391 }
4392
4393
4394 SWIGINTERN PyObject *_wrap_new_Message(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4395   PyObject *resultobj = 0;
4396   ldb_dn *arg1 = (ldb_dn *) NULL ;
4397   void *argp1 = 0 ;
4398   int res1 = 0 ;
4399   PyObject * obj0 = 0 ;
4400   char *  kwnames[] = {
4401     (char *) "dn", NULL
4402   };
4403   ldb_msg *result = 0 ;
4404
4405   if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_Message",kwnames,&obj0)) SWIG_fail;
4406   if (obj0) {
4407     res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ldb_dn, 0 |  0 );
4408     if (!SWIG_IsOK(res1)) {
4409       SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Message" "', argument " "1"" of type '" "ldb_dn *""'");
4410     }
4411     arg1 = (ldb_dn *)(argp1);
4412   }
4413   result = (ldb_msg *)new_ldb_msg(arg1);
4414   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ldb_message, SWIG_POINTER_NEW |  0 );
4415   return resultobj;
4416 fail:
4417   return NULL;
4418 }
4419
4420
4421 SWIGINTERN PyObject *_wrap_delete_Message(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4422   PyObject *resultobj = 0;
4423   ldb_msg *arg1 = (ldb_msg *) 0 ;
4424   void *argp1 = 0 ;
4425   int res1 = 0 ;
4426   PyObject *swig_obj[1] ;
4427
4428   if (!args) SWIG_fail;
4429   swig_obj[0] = args;
4430   res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ldb_message, SWIG_POINTER_DISOWN |  0 );
4431   if (!SWIG_IsOK(res1)) {
4432     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Message" "', argument " "1"" of type '" "ldb_msg *""'");
4433   }
4434   arg1 = (ldb_msg *)(argp1);
4435   if (arg1 == NULL)
4436   SWIG_exception(SWIG_ValueError,
4437     "Message can not be None");
4438   delete_ldb_msg(arg1);
4439   resultobj = SWIG_Py_Void();
4440   return resultobj;
4441 fail:
4442   return NULL;
4443 }
4444
4445
4446 SWIGINTERN PyObject *_wrap_Message_find_element(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4447   PyObject *resultobj = 0;
4448   ldb_msg *arg1 = (ldb_msg *) 0 ;
4449   char *arg2 = (char *) 0 ;
4450   void *argp1 = 0 ;
4451   int res1 = 0 ;
4452   int res2 ;
4453   char *buf2 = 0 ;
4454   int alloc2 = 0 ;
4455   PyObject * obj0 = 0 ;
4456   PyObject * obj1 = 0 ;
4457   char *  kwnames[] = {
4458     (char *) "self",(char *) "name", NULL
4459   };
4460   ldb_message_element *result = 0 ;
4461
4462   if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Message_find_element",kwnames,&obj0,&obj1)) SWIG_fail;
4463   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ldb_message, 0 |  0 );
4464   if (!SWIG_IsOK(res1)) {
4465     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Message_find_element" "', argument " "1"" of type '" "ldb_msg *""'");
4466   }
4467   arg1 = (ldb_msg *)(argp1);
4468   res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
4469   if (!SWIG_IsOK(res2)) {
4470     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Message_find_element" "', argument " "2"" of type '" "char const *""'");
4471   }
4472   arg2 = (char *)(buf2);
4473   if (arg1 == NULL)
4474   SWIG_exception(SWIG_ValueError,
4475     "Message can not be None");
4476   result = (ldb_message_element *)ldb_msg_find_element(arg1,(char const *)arg2);
4477   {
4478     if (result == NULL)
4479     PyErr_SetString(PyExc_KeyError, "no such element");
4480     else
4481     resultobj = SWIG_NewPointerObj(result, SWIGTYPE_p_ldb_message_element, 0);
4482   }
4483   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
4484   return resultobj;
4485 fail:
4486   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
4487   return NULL;
4488 }
4489
4490
4491 SWIGINTERN PyObject *_wrap_Message___setitem____SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
4492   PyObject *resultobj = 0;
4493   ldb_msg *arg1 = (ldb_msg *) 0 ;
4494   char *arg2 = (char *) 0 ;
4495   ldb_message_element *arg3 = (ldb_message_element *) 0 ;
4496   void *argp1 = 0 ;
4497   int res1 = 0 ;
4498   int res2 ;
4499   char *buf2 = 0 ;
4500   int alloc2 = 0 ;
4501   void *argp3 = 0 ;
4502   int res3 = 0 ;
4503
4504   if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
4505   res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ldb_message, 0 |  0 );
4506   if (!SWIG_IsOK(res1)) {
4507     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Message___setitem__" "', argument " "1"" of type '" "ldb_msg *""'");
4508   }
4509   arg1 = (ldb_msg *)(argp1);
4510   res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
4511   if (!SWIG_IsOK(res2)) {
4512     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Message___setitem__" "', argument " "2"" of type '" "char const *""'");
4513   }
4514   arg2 = (char *)(buf2);
4515   res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_ldb_message_element, 0 |  0 );
4516   if (!SWIG_IsOK(res3)) {
4517     SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Message___setitem__" "', argument " "3"" of type '" "ldb_message_element *""'");
4518   }
4519   arg3 = (ldb_message_element *)(argp3);
4520   if (arg1 == NULL)
4521   SWIG_exception(SWIG_ValueError,
4522     "Message can not be None");
4523   ldb_msg___setitem____SWIG_0(arg1,(char const *)arg2,arg3);
4524   resultobj = SWIG_Py_Void();
4525   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
4526   return resultobj;
4527 fail:
4528   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
4529   return NULL;
4530 }
4531
4532
4533 SWIGINTERN PyObject *_wrap_Message___setitem____SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
4534   PyObject *resultobj = 0;
4535   ldb_msg *arg1 = (ldb_msg *) 0 ;
4536   char *arg2 = (char *) 0 ;
4537   PyObject *arg3 = (PyObject *) 0 ;
4538   void *argp1 = 0 ;
4539   int res1 = 0 ;
4540   int res2 ;
4541   char *buf2 = 0 ;
4542   int alloc2 = 0 ;
4543
4544   if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
4545   res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ldb_message, 0 |  0 );
4546   if (!SWIG_IsOK(res1)) {
4547     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Message___setitem__" "', argument " "1"" of type '" "ldb_msg *""'");
4548   }
4549   arg1 = (ldb_msg *)(argp1);
4550   res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
4551   if (!SWIG_IsOK(res2)) {
4552     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Message___setitem__" "', argument " "2"" of type '" "char const *""'");
4553   }
4554   arg2 = (char *)(buf2);
4555   arg3 = swig_obj[2];
4556   if (arg1 == NULL)
4557   SWIG_exception(SWIG_ValueError,
4558     "Message can not be None");
4559   ldb_msg___setitem____SWIG_1(arg1,(char const *)arg2,arg3);
4560   resultobj = SWIG_Py_Void();
4561   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
4562   return resultobj;
4563 fail:
4564   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
4565   return NULL;
4566 }
4567
4568
4569 SWIGINTERN PyObject *_wrap_Message___setitem__(PyObject *self, PyObject *args) {
4570   int argc;
4571   PyObject *argv[4];
4572
4573   if (!(argc = SWIG_Python_UnpackTuple(args,"Message___setitem__",0,3,argv))) SWIG_fail;
4574   --argc;
4575   if (argc == 3) {
4576     int _v = 0;
4577     {
4578       void *vptr = 0;
4579       int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_ldb_message_element, 0);
4580       _v = SWIG_CheckState(res);
4581     }
4582     if (!_v) goto check_1;
4583     return _wrap_Message___setitem____SWIG_0(self, argc, argv);
4584   }
4585 check_1:
4586
4587   if (argc == 3) {
4588     return _wrap_Message___setitem____SWIG_1(self, argc, argv);
4589   }
4590
4591 fail:
4592   SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'Message___setitem__'.\n"
4593     "  Possible C/C++ prototypes are:\n"
4594     "    __setitem__(ldb_msg *,char const *,ldb_message_element *)\n"
4595     "    __setitem__(ldb_msg *,char const *,PyObject *)\n");
4596   return NULL;
4597 }
4598
4599
4600 SWIGINTERN PyObject *_wrap_Message___len__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4601   PyObject *resultobj = 0;
4602   ldb_msg *arg1 = (ldb_msg *) 0 ;
4603   void *argp1 = 0 ;
4604   int res1 = 0 ;
4605   PyObject *swig_obj[1] ;
4606   unsigned int result;
4607
4608   if (!args) SWIG_fail;
4609   swig_obj[0] = args;
4610   res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ldb_message, 0 |  0 );
4611   if (!SWIG_IsOK(res1)) {
4612     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Message___len__" "', argument " "1"" of type '" "ldb_msg *""'");
4613   }
4614   arg1 = (ldb_msg *)(argp1);
4615   if (arg1 == NULL)
4616   SWIG_exception(SWIG_ValueError,
4617     "Message can not be None");
4618   result = (unsigned int)ldb_msg___len__(arg1);
4619   resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
4620   return resultobj;
4621 fail:
4622   return NULL;
4623 }
4624
4625
4626 SWIGINTERN PyObject *_wrap_Message_keys(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4627   PyObject *resultobj = 0;
4628   ldb_msg *arg1 = (ldb_msg *) 0 ;
4629   void *argp1 = 0 ;
4630   int res1 = 0 ;
4631   PyObject *swig_obj[1] ;
4632   PyObject *result = 0 ;
4633
4634   if (!args) SWIG_fail;
4635   swig_obj[0] = args;
4636   res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ldb_message, 0 |  0 );
4637   if (!SWIG_IsOK(res1)) {
4638     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Message_keys" "', argument " "1"" of type '" "ldb_msg *""'");
4639   }
4640   arg1 = (ldb_msg *)(argp1);
4641   if (arg1 == NULL)
4642   SWIG_exception(SWIG_ValueError,
4643     "Message can not be None");
4644   result = (PyObject *)ldb_msg_keys(arg1);
4645   resultobj = result;
4646   return resultobj;
4647 fail:
4648   return NULL;
4649 }
4650
4651
4652 SWIGINTERN PyObject *_wrap_Message___iter__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4653   PyObject *resultobj = 0;
4654   ldb_msg *arg1 = (ldb_msg *) 0 ;
4655   void *argp1 = 0 ;
4656   int res1 = 0 ;
4657   PyObject *swig_obj[1] ;
4658   PyObject *result = 0 ;
4659
4660   if (!args) SWIG_fail;
4661   swig_obj[0] = args;
4662   res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ldb_message, 0 |  0 );
4663   if (!SWIG_IsOK(res1)) {
4664     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Message___iter__" "', argument " "1"" of type '" "ldb_msg *""'");
4665   }
4666   arg1 = (ldb_msg *)(argp1);
4667   if (arg1 == NULL)
4668   SWIG_exception(SWIG_ValueError,
4669     "Message can not be None");
4670   result = (PyObject *)ldb_msg___iter__(arg1);
4671   resultobj = result;
4672   return resultobj;
4673 fail:
4674   return NULL;
4675 }
4676
4677
4678 SWIGINTERN PyObject *_wrap_Message___delitem__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4679   PyObject *resultobj = 0;
4680   ldb_msg *arg1 = (ldb_msg *) 0 ;
4681   char *arg2 = (char *) 0 ;
4682   void *argp1 = 0 ;
4683   int res1 = 0 ;
4684   int res2 ;
4685   char *buf2 = 0 ;
4686   int alloc2 = 0 ;
4687   PyObject * obj0 = 0 ;
4688   PyObject * obj1 = 0 ;
4689   char *  kwnames[] = {
4690     (char *) "self",(char *) "name", NULL
4691   };
4692
4693   if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Message___delitem__",kwnames,&obj0,&obj1)) SWIG_fail;
4694   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ldb_message, 0 |  0 );
4695   if (!SWIG_IsOK(res1)) {
4696     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Message___delitem__" "', argument " "1"" of type '" "ldb_msg *""'");
4697   }
4698   arg1 = (ldb_msg *)(argp1);
4699   res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
4700   if (!SWIG_IsOK(res2)) {
4701     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Message___delitem__" "', argument " "2"" of type '" "char const *""'");
4702   }
4703   arg2 = (char *)(buf2);
4704   if (arg1 == NULL)
4705   SWIG_exception(SWIG_ValueError,
4706     "Message can not be None");
4707   ldb_msg_remove_attr(arg1,(char const *)arg2);
4708   resultobj = SWIG_Py_Void();
4709   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
4710   return resultobj;
4711 fail:
4712   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
4713   return NULL;
4714 }
4715
4716
4717 SWIGINTERN PyObject *Message_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4718   PyObject *obj;
4719   if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
4720   SWIG_TypeNewClientData(SWIGTYPE_p_ldb_message, SWIG_NewClientData(obj));
4721   return SWIG_Py_Void();
4722 }
4723
4724 SWIGINTERN PyObject *Message_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4725   return SWIG_Python_InitShadowInstance(args);
4726 }
4727
4728 SWIGINTERN PyObject *_wrap_ldb_ldif_to_pyobject(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4729   PyObject *resultobj = 0;
4730   ldb_ldif *arg1 = (ldb_ldif *) 0 ;
4731   void *argp1 = 0 ;
4732   int res1 = 0 ;
4733   PyObject * obj0 = 0 ;
4734   char *  kwnames[] = {
4735     (char *) "ldif", NULL
4736   };
4737   PyObject *result = 0 ;
4738
4739   if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ldb_ldif_to_pyobject",kwnames,&obj0)) SWIG_fail;
4740   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ldb_ldif, 0 |  0 );
4741   if (!SWIG_IsOK(res1)) {
4742     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ldb_ldif_to_pyobject" "', argument " "1"" of type '" "ldb_ldif *""'");
4743   }
4744   arg1 = (ldb_ldif *)(argp1);
4745   result = (PyObject *)ldb_ldif_to_pyobject(arg1);
4746   resultobj = result;
4747   return resultobj;
4748 fail:
4749   return NULL;
4750 }
4751
4752
4753 SWIGINTERN PyObject *_wrap_Ldb_firstmodule_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4754   PyObject *resultobj = 0;
4755   ldb *arg1 = (ldb *) 0 ;
4756   struct ldb_module *arg2 = (struct ldb_module *) 0 ;
4757   void *argp1 = 0 ;
4758   int res1 = 0 ;
4759   void *argp2 = 0 ;
4760   int res2 = 0 ;
4761   PyObject *swig_obj[2] ;
4762
4763   if (!SWIG_Python_UnpackTuple(args,"Ldb_firstmodule_set",2,2,swig_obj)) SWIG_fail;
4764   res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ldb_context, 0 |  0 );
4765   if (!SWIG_IsOK(res1)) {
4766     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Ldb_firstmodule_set" "', argument " "1"" of type '" "ldb *""'");
4767   }
4768   arg1 = (ldb *)(argp1);
4769   res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_ldb_module, SWIG_POINTER_DISOWN |  0 );
4770   if (!SWIG_IsOK(res2)) {
4771     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Ldb_firstmodule_set" "', argument " "2"" of type '" "struct ldb_module *""'");
4772   }
4773   arg2 = (struct ldb_module *)(argp2);
4774   if (arg1 == NULL)
4775   SWIG_exception(SWIG_ValueError,
4776     "ldb context must be non-NULL");
4777   if (arg1) (arg1)->modules = arg2;
4778   resultobj = SWIG_Py_Void();
4779   return resultobj;
4780 fail:
4781   return NULL;
4782 }
4783
4784
4785 SWIGINTERN PyObject *_wrap_Ldb_firstmodule_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4786   PyObject *resultobj = 0;
4787   ldb *arg1 = (ldb *) 0 ;
4788   void *argp1 = 0 ;
4789   int res1 = 0 ;
4790   PyObject *swig_obj[1] ;
4791   struct ldb_module *result = 0 ;
4792
4793   if (!args) SWIG_fail;
4794   swig_obj[0] = args;
4795   res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ldb_context, 0 |  0 );
4796   if (!SWIG_IsOK(res1)) {
4797     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Ldb_firstmodule_get" "', argument " "1"" of type '" "ldb *""'");
4798   }
4799   arg1 = (ldb *)(argp1);
4800   if (arg1 == NULL)
4801   SWIG_exception(SWIG_ValueError,
4802     "ldb context must be non-NULL");
4803   result = (struct ldb_module *) ((arg1)->modules);
4804   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ldb_module, 0 |  0 );
4805   return resultobj;
4806 fail:
4807   return NULL;
4808 }
4809
4810
4811 SWIGINTERN PyObject *_wrap_new_Ldb(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4812   PyObject *resultobj = 0;
4813   ldb *result = 0 ;
4814
4815   if (!SWIG_Python_UnpackTuple(args,"new_Ldb",0,0,0)) SWIG_fail;
4816   result = (ldb *)new_ldb();
4817   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ldb_context, SWIG_POINTER_NEW |  0 );
4818   return resultobj;
4819 fail:
4820   return NULL;
4821 }
4822
4823
4824 SWIGINTERN PyObject *_wrap_Ldb_connect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4825   PyObject *resultobj = 0;
4826   ldb *arg1 = (ldb *) 0 ;
4827   char *arg2 = (char *) 0 ;
4828   unsigned int arg3 = (unsigned int) 0 ;
4829   char **arg4 = (char **) (char **)NULL ;
4830   void *argp1 = 0 ;
4831   int res1 = 0 ;
4832   int res2 ;
4833   char *buf2 = 0 ;
4834   int alloc2 = 0 ;
4835   unsigned int val3 ;
4836   int ecode3 = 0 ;
4837   void *argp4 = 0 ;
4838   int res4 = 0 ;
4839   PyObject * obj0 = 0 ;
4840   PyObject * obj1 = 0 ;
4841   PyObject * obj2 = 0 ;
4842   PyObject * obj3 = 0 ;
4843   char *  kwnames[] = {
4844     (char *) "self",(char *) "url",(char *) "flags",(char *) "options", NULL
4845   };
4846   ldb_error result;
4847
4848   if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Ldb_connect",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
4849   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ldb_context, 0 |  0 );
4850   if (!SWIG_IsOK(res1)) {
4851     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Ldb_connect" "', argument " "1"" of type '" "ldb *""'");
4852   }
4853   arg1 = (ldb *)(argp1);
4854   res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
4855   if (!SWIG_IsOK(res2)) {
4856     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Ldb_connect" "', argument " "2"" of type '" "char const *""'");
4857   }
4858   arg2 = (char *)(buf2);
4859   if (obj2) {
4860     ecode3 = SWIG_AsVal_unsigned_SS_int(obj2, &val3);
4861     if (!SWIG_IsOK(ecode3)) {
4862       SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Ldb_connect" "', argument " "3"" of type '" "unsigned int""'");
4863     }
4864     arg3 = (unsigned int)(val3);
4865   }
4866   if (obj3) {
4867     res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_p_char, 0 |  0 );
4868     if (!SWIG_IsOK(res4)) {
4869       SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Ldb_connect" "', argument " "4"" of type '" "char const *[]""'");
4870     }
4871     arg4 = (char **)(argp4);
4872   }
4873   if (arg1 == NULL)
4874   SWIG_exception(SWIG_ValueError,
4875     "ldb context must be non-NULL");
4876   result = ldb_connect(arg1,(char const *)arg2,arg3,(char const *(*))arg4);
4877   if (result != 0) {
4878     PyErr_SetObject(PyExc_LdbError, Py_BuildValue((char *)"(i,s)", result, ldb_errstring(arg1)));
4879     SWIG_fail;
4880   }
4881   resultobj = Py_None;
4882   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
4883   return resultobj;
4884 fail:
4885   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
4886   return NULL;
4887 }
4888
4889
4890 SWIGINTERN PyObject *_wrap_delete_Ldb(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4891   PyObject *resultobj = 0;
4892   ldb *arg1 = (ldb *) 0 ;
4893   void *argp1 = 0 ;
4894   int res1 = 0 ;
4895   PyObject *swig_obj[1] ;
4896
4897   if (!args) SWIG_fail;
4898   swig_obj[0] = args;
4899   res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ldb_context, SWIG_POINTER_DISOWN |  0 );
4900   if (!SWIG_IsOK(res1)) {
4901     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Ldb" "', argument " "1"" of type '" "ldb *""'");
4902   }
4903   arg1 = (ldb *)(argp1);
4904   if (arg1 == NULL)
4905   SWIG_exception(SWIG_ValueError,
4906     "ldb context must be non-NULL");
4907   delete_ldb(arg1);
4908   resultobj = SWIG_Py_Void();
4909   return resultobj;
4910 fail:
4911   return NULL;
4912 }
4913
4914
4915 SWIGINTERN PyObject *_wrap_Ldb_search_ex(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4916   PyObject *resultobj = 0;
4917   ldb *arg1 = (ldb *) 0 ;
4918   TALLOC_CTX *arg2 = (TALLOC_CTX *) 0 ;
4919   ldb_dn *arg3 = (ldb_dn *) NULL ;
4920   enum ldb_scope arg4 = (enum ldb_scope) LDB_SCOPE_DEFAULT ;
4921   char *arg5 = (char *) NULL ;
4922   char **arg6 = (char **) NULL ;
4923   struct ldb_control **arg7 = (struct ldb_control **) NULL ;
4924   struct ldb_result **arg8 = (struct ldb_result **) 0 ;
4925   void *argp1 = 0 ;
4926   int res1 = 0 ;
4927   int val4 ;
4928   int ecode4 = 0 ;
4929   int res5 ;
4930   char *buf5 = 0 ;
4931   int alloc5 = 0 ;
4932   void *argp7 = 0 ;
4933   int res7 = 0 ;
4934   struct ldb_result *temp_ldb_result8 ;
4935   int i8 ;
4936   PyObject * obj0 = 0 ;
4937   PyObject * obj1 = 0 ;
4938   PyObject * obj2 = 0 ;
4939   PyObject * obj3 = 0 ;
4940   PyObject * obj4 = 0 ;
4941   PyObject * obj5 = 0 ;
4942   char *  kwnames[] = {
4943     (char *) "self",(char *) "base",(char *) "scope",(char *) "expression",(char *) "attrs",(char *) "controls", NULL
4944   };
4945   ldb_error result;
4946
4947   arg2 = NULL;
4948   arg8 = &temp_ldb_result8;
4949   if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOO:Ldb_search_ex",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
4950   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ldb_context, 0 |  0 );
4951   if (!SWIG_IsOK(res1)) {
4952     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Ldb_search_ex" "', argument " "1"" of type '" "ldb *""'");
4953   }
4954   arg1 = (ldb *)(argp1);
4955   if (obj1) {
4956     if (ldb_dn_from_pyobject(NULL, obj1, arg1, &arg3) != 0) {
4957       SWIG_fail;
4958     }
4959   }
4960   if (obj2) {
4961     ecode4 = SWIG_AsVal_int(obj2, &val4);
4962     if (!SWIG_IsOK(ecode4)) {
4963       SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Ldb_search_ex" "', argument " "4"" of type '" "enum ldb_scope""'");
4964     }
4965     arg4 = (enum ldb_scope)(val4);
4966   }
4967   if (obj3) {
4968     res5 = SWIG_AsCharPtrAndSize(obj3, &buf5, NULL, &alloc5);
4969     if (!SWIG_IsOK(res5)) {
4970       SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "Ldb_search_ex" "', argument " "5"" of type '" "char const *""'");
4971     }
4972     arg5 = (char *)(buf5);
4973   }
4974   if (obj4) {
4975     if (obj4 == Py_None) {
4976       arg6 = NULL;
4977     } else if (PySequence_Check(obj4)) {
4978       int i;
4979       arg6 = talloc_array(NULL, char *, PySequence_Size(obj4)+1);
4980       for(i = 0; i < PySequence_Size(obj4); i++)
4981       arg6[i] = PyString_AsString(PySequence_GetItem(obj4, i));
4982       arg6[i] = NULL;
4983     } else {
4984       SWIG_exception(SWIG_TypeError, "expected sequence");
4985     }
4986   }
4987   if (obj5) {
4988     res7 = SWIG_ConvertPtr(obj5, &argp7,SWIGTYPE_p_p_ldb_control, 0 |  0 );
4989     if (!SWIG_IsOK(res7)) {
4990       SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "Ldb_search_ex" "', argument " "7"" of type '" "struct ldb_control **""'");
4991     }
4992     arg7 = (struct ldb_control **)(argp7);
4993   }
4994   if (arg1 == NULL)
4995   SWIG_exception(SWIG_ValueError,
4996     "ldb context must be non-NULL");
4997   result = ldb_search_ex(arg1,arg2,arg3,arg4,(char const *)arg5,(char const *const *)arg6,arg7,arg8);
4998   if (result != 0) {
4999     PyErr_SetObject(PyExc_LdbError, Py_BuildValue((char *)"(i,s)", result, ldb_errstring(arg1)));
5000     SWIG_fail;
5001   }
5002   resultobj = Py_None;
5003   resultobj = PyList_New((*arg8)->count);
5004   for (i8 = 0; i8 < (*arg8)->count; i8++) {
5005     PyList_SetItem(resultobj, i8,
5006       SWIG_NewPointerObj((*arg8)->msgs[i8], SWIGTYPE_p_ldb_message, 0)
5007       );
5008   }
5009   talloc_free(arg3);
5010   if (alloc5 == SWIG_NEWOBJ) free((char*)buf5);
5011   talloc_free(arg6);
5012   return resultobj;
5013 fail:
5014   talloc_free(arg3);
5015   if (alloc5 == SWIG_NEWOBJ) free((char*)buf5);
5016   talloc_free(arg6);
5017   return NULL;
5018 }
5019
5020
5021 SWIGINTERN PyObject *_wrap_Ldb_delete(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5022   PyObject *resultobj = 0;
5023   ldb *arg1 = (ldb *) 0 ;
5024   ldb_dn *arg2 = (ldb_dn *) 0 ;
5025   void *argp1 = 0 ;
5026   int res1 = 0 ;
5027   PyObject * obj0 = 0 ;
5028   PyObject * obj1 = 0 ;
5029   char *  kwnames[] = {
5030     (char *) "self",(char *) "dn", NULL
5031   };
5032   ldb_error result;
5033
5034   if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Ldb_delete",kwnames,&obj0,&obj1)) SWIG_fail;
5035   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ldb_context, 0 |  0 );
5036   if (!SWIG_IsOK(res1)) {
5037     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Ldb_delete" "', argument " "1"" of type '" "ldb *""'");
5038   }
5039   arg1 = (ldb *)(argp1);
5040   if (ldb_dn_from_pyobject(NULL, obj1, arg1, &arg2) != 0) {
5041     SWIG_fail;
5042   }
5043   if (arg1 == NULL)
5044   SWIG_exception(SWIG_ValueError,
5045     "ldb context must be non-NULL");
5046   result = ldb_delete(arg1,arg2);
5047   if (result != 0) {
5048     PyErr_SetObject(PyExc_LdbError, Py_BuildValue((char *)"(i,s)", result, ldb_errstring(arg1)));
5049     SWIG_fail;
5050   }
5051   resultobj = Py_None;
5052   talloc_free(arg2);
5053   return resultobj;
5054 fail:
5055   talloc_free(arg2);
5056   return NULL;
5057 }
5058
5059
5060 SWIGINTERN PyObject *_wrap_Ldb_rename(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5061   PyObject *resultobj = 0;
5062   ldb *arg1 = (ldb *) 0 ;
5063   ldb_dn *arg2 = (ldb_dn *) 0 ;
5064   ldb_dn *arg3 = (ldb_dn *) 0 ;
5065   void *argp1 = 0 ;
5066   int res1 = 0 ;
5067   PyObject * obj0 = 0 ;
5068   PyObject * obj1 = 0 ;
5069   PyObject * obj2 = 0 ;
5070   char *  kwnames[] = {
5071     (char *) "self",(char *) "olddn",(char *) "newdn", NULL
5072   };
5073   ldb_error result;
5074
5075   if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Ldb_rename",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
5076   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ldb_context, 0 |  0 );
5077   if (!SWIG_IsOK(res1)) {
5078     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Ldb_rename" "', argument " "1"" of type '" "ldb *""'");
5079   }
5080   arg1 = (ldb *)(argp1);
5081   if (ldb_dn_from_pyobject(NULL, obj1, arg1, &arg2) != 0) {
5082     SWIG_fail;
5083   }
5084   if (ldb_dn_from_pyobject(NULL, obj2, arg1, &arg3) != 0) {
5085     SWIG_fail;
5086   }
5087   if (arg1 == NULL)
5088   SWIG_exception(SWIG_ValueError,
5089     "ldb context must be non-NULL");
5090   result = ldb_rename(arg1,arg2,arg3);
5091   if (result != 0) {
5092     PyErr_SetObject(PyExc_LdbError, Py_BuildValue((char *)"(i,s)", result, ldb_errstring(arg1)));
5093     SWIG_fail;
5094   }
5095   resultobj = Py_None;
5096   talloc_free(arg2);
5097   talloc_free(arg3);
5098   return resultobj;
5099 fail:
5100   talloc_free(arg2);
5101   talloc_free(arg3);
5102   return NULL;
5103 }
5104
5105
5106 SWIGINTERN PyObject *_wrap_Ldb_parse_control_strings(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5107   PyObject *resultobj = 0;
5108   ldb *arg1 = (ldb *) 0 ;
5109   TALLOC_CTX *arg2 = (TALLOC_CTX *) 0 ;
5110   char **arg3 = (char **) 0 ;
5111   void *argp1 = 0 ;
5112   int res1 = 0 ;
5113   PyObject * obj0 = 0 ;
5114   PyObject * obj1 = 0 ;
5115   char *  kwnames[] = {
5116     (char *) "self",(char *) "control_strings", NULL
5117   };
5118   struct ldb_control **result = 0 ;
5119
5120   arg2 = NULL;
5121   if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Ldb_parse_control_strings",kwnames,&obj0,&obj1)) SWIG_fail;
5122   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ldb_context, 0 |  0 );
5123   if (!SWIG_IsOK(res1)) {
5124     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Ldb_parse_control_strings" "', argument " "1"" of type '" "ldb *""'");
5125   }
5126   arg1 = (ldb *)(argp1);
5127   if (obj1 == Py_None) {
5128     arg3 = NULL;
5129   } else if (PySequence_Check(obj1)) {
5130     int i;
5131     arg3 = talloc_array(NULL, char *, PySequence_Size(obj1)+1);
5132     for(i = 0; i < PySequence_Size(obj1); i++)
5133     arg3[i] = PyString_AsString(PySequence_GetItem(obj1, i));
5134     arg3[i] = NULL;
5135   } else {
5136     SWIG_exception(SWIG_TypeError, "expected sequence");
5137   }
5138   if (arg1 == NULL)
5139   SWIG_exception(SWIG_ValueError,
5140     "ldb context must be non-NULL");
5141   result = (struct ldb_control **)ldb_parse_control_strings(arg1,arg2,(char const *const *)arg3);
5142   if (result == NULL) {
5143     PyErr_SetObject(PyExc_LdbError, Py_BuildValue((char *)"(s)", ldb_errstring(arg1)));
5144     SWIG_fail;
5145   }
5146   resultobj = SWIG_NewPointerObj(result, SWIGTYPE_p_p_ldb_control, 0);
5147   talloc_free(arg3);
5148   return resultobj;
5149 fail:
5150   talloc_free(arg3);
5151   return NULL;
5152 }
5153
5154
5155 SWIGINTERN PyObject *_wrap_Ldb_add(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5156   PyObject *resultobj = 0;
5157   ldb *arg1 = (ldb *) 0 ;
5158   ldb_msg *arg2 = (ldb_msg *) 0 ;
5159   void *argp1 = 0 ;
5160   int res1 = 0 ;
5161   PyObject * obj0 = 0 ;
5162   PyObject * obj1 = 0 ;
5163   char *  kwnames[] = {
5164     (char *) "self",(char *) "add_msg", NULL
5165   };
5166   ldb_error result;
5167
5168   if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Ldb_add",kwnames,&obj0,&obj1)) SWIG_fail;
5169   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ldb_context, 0 |  0 );
5170   if (!SWIG_IsOK(res1)) {
5171     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Ldb_add" "', argument " "1"" of type '" "ldb *""'");
5172   }
5173   arg1 = (ldb *)(argp1);
5174   {
5175     Py_ssize_t dict_pos, msg_pos;
5176     ldb_message_element *msgel;
5177     PyObject *key, *value;
5178
5179     if (PyDict_Check(obj1)) {
5180       PyObject *dn_value = PyDict_GetItemString(obj1, "dn");
5181       arg2 = ldb_msg_new(NULL);
5182       arg2->elements = talloc_zero_array(arg2, struct ldb_message_element, PyDict_Size(obj1));
5183       msg_pos = dict_pos = 0;
5184       if (dn_value) {
5185         /* using argp1 (magic SWIG value) here is a hack */
5186         if (ldb_dn_from_pyobject(arg2, dn_value, argp1, &arg2->dn) != 0) {
5187           SWIG_exception(SWIG_TypeError, "unable to import dn object");
5188         }
5189         if (arg2->dn == NULL) {
5190           SWIG_exception(SWIG_TypeError, "dn set but not found");
5191         }
5192       }
5193
5194       while (PyDict_Next(obj1, &dict_pos, &key, &value)) {
5195         char *key_str = PyString_AsString(key);
5196         if (strcmp(key_str, "dn") != 0) {
5197           msgel = ldb_msg_element_from_pyobject(arg2->elements, value, 0, key_str);
5198           if (msgel == NULL) {
5199             SWIG_exception(SWIG_TypeError, "unable to import element");
5200           }
5201           memcpy(&arg2->elements[msg_pos], msgel, sizeof(*msgel));
5202           msg_pos++;
5203         }
5204       }
5205
5206       if (arg2->dn == NULL) {
5207         SWIG_exception(SWIG_TypeError, "no dn set");
5208       }
5209
5210       arg2->num_elements = msg_pos;
5211     } else {
5212       if (SWIG_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_ldb_message, 0) != 0) {
5213         SWIG_exception(SWIG_TypeError, "unable to convert ldb message");
5214       }
5215     }
5216   }
5217   if (arg1 == NULL)
5218   SWIG_exception(SWIG_ValueError,
5219     "ldb context must be non-NULL");
5220   if (arg2 == NULL)
5221   SWIG_exception(SWIG_ValueError,
5222     "Message can not be None");
5223   result = ldb_add(arg1,arg2);
5224   if (result != 0) {
5225     PyErr_SetObject(PyExc_LdbError, Py_BuildValue((char *)"(i,s)", result, ldb_errstring(arg1)));
5226     SWIG_fail;
5227   }
5228   resultobj = Py_None;
5229   return resultobj;
5230 fail:
5231   return NULL;
5232 }
5233
5234
5235 SWIGINTERN PyObject *_wrap_Ldb_modify(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5236   PyObject *resultobj = 0;
5237   ldb *arg1 = (ldb *) 0 ;
5238   ldb_msg *arg2 = (ldb_msg *) 0 ;
5239   void *argp1 = 0 ;
5240   int res1 = 0 ;
5241   void *argp2 = 0 ;
5242   int res2 = 0 ;
5243   PyObject * obj0 = 0 ;
5244   PyObject * obj1 = 0 ;
5245   char *  kwnames[] = {
5246     (char *) "self",(char *) "message", NULL
5247   };
5248   ldb_error result;
5249
5250   if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Ldb_modify",kwnames,&obj0,&obj1)) SWIG_fail;
5251   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ldb_context, 0 |  0 );
5252   if (!SWIG_IsOK(res1)) {
5253     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Ldb_modify" "', argument " "1"" of type '" "ldb *""'");
5254   }
5255   arg1 = (ldb *)(argp1);
5256   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_ldb_message, 0 |  0 );
5257   if (!SWIG_IsOK(res2)) {
5258     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Ldb_modify" "', argument " "2"" of type '" "ldb_msg *""'");
5259   }
5260   arg2 = (ldb_msg *)(argp2);
5261   if (arg1 == NULL)
5262   SWIG_exception(SWIG_ValueError,
5263     "ldb context must be non-NULL");
5264   if (arg2 == NULL)
5265   SWIG_exception(SWIG_ValueError,
5266     "Message can not be None");
5267   result = ldb_modify(arg1,arg2);
5268   if (result != 0) {
5269     PyErr_SetObject(PyExc_LdbError, Py_BuildValue((char *)"(i,s)", result, ldb_errstring(arg1)));
5270     SWIG_fail;
5271   }
5272   resultobj = Py_None;
5273   return resultobj;
5274 fail:
5275   return NULL;
5276 }
5277
5278
5279 SWIGINTERN PyObject *_wrap_Ldb_get_config_basedn(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5280   PyObject *resultobj = 0;
5281   ldb *arg1 = (ldb *) 0 ;
5282   void *argp1 = 0 ;
5283   int res1 = 0 ;
5284   PyObject *swig_obj[1] ;
5285   ldb_dn *result = 0 ;
5286
5287   if (!args) SWIG_fail;
5288   swig_obj[0] = args;
5289   res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ldb_context, 0 |  0 );
5290   if (!SWIG_IsOK(res1)) {
5291     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Ldb_get_config_basedn" "', argument " "1"" of type '" "ldb *""'");
5292   }
5293   arg1 = (ldb *)(argp1);
5294   if (arg1 == NULL)
5295   SWIG_exception(SWIG_ValueError,
5296     "ldb context must be non-NULL");
5297   result = (ldb_dn *)ldb_get_config_basedn(arg1);
5298   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ldb_dn, 0 |  0 );
5299   return resultobj;
5300 fail:
5301   return NULL;
5302 }
5303
5304
5305 SWIGINTERN PyObject *_wrap_Ldb_get_root_basedn(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5306   PyObject *resultobj = 0;
5307   ldb *arg1 = (ldb *) 0 ;
5308   void *argp1 = 0 ;
5309   int res1 = 0 ;
5310   PyObject *swig_obj[1] ;
5311   ldb_dn *result = 0 ;
5312
5313   if (!args) SWIG_fail;
5314   swig_obj[0] = args;
5315   res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ldb_context, 0 |  0 );
5316   if (!SWIG_IsOK(res1)) {
5317     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Ldb_get_root_basedn" "', argument " "1"" of type '" "ldb *""'");
5318   }
5319   arg1 = (ldb *)(argp1);
5320   if (arg1 == NULL)
5321   SWIG_exception(SWIG_ValueError,
5322     "ldb context must be non-NULL");
5323   result = (ldb_dn *)ldb_get_root_basedn(arg1);
5324   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ldb_dn, 0 |  0 );
5325   return resultobj;
5326 fail:
5327   return NULL;
5328 }
5329
5330
5331 SWIGINTERN PyObject *_wrap_Ldb_get_schema_basedn(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5332   PyObject *resultobj = 0;
5333   ldb *arg1 = (ldb *) 0 ;
5334   void *argp1 = 0 ;
5335   int res1 = 0 ;
5336   PyObject *swig_obj[1] ;
5337   ldb_dn *result = 0 ;
5338
5339   if (!args) SWIG_fail;
5340   swig_obj[0] = args;
5341   res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ldb_context, 0 |  0 );
5342   if (!SWIG_IsOK(res1)) {
5343     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Ldb_get_schema_basedn" "', argument " "1"" of type '" "ldb *""'");
5344   }
5345   arg1 = (ldb *)(argp1);
5346   if (arg1 == NULL)
5347   SWIG_exception(SWIG_ValueError,
5348     "ldb context must be non-NULL");
5349   result = (ldb_dn *)ldb_get_schema_basedn(arg1);
5350   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ldb_dn, 0 |  0 );
5351   return resultobj;
5352 fail:
5353   return NULL;
5354 }
5355
5356
5357 SWIGINTERN PyObject *_wrap_Ldb_get_default_basedn(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5358   PyObject *resultobj = 0;
5359   ldb *arg1 = (ldb *) 0 ;
5360   void *argp1 = 0 ;
5361   int res1 = 0 ;
5362   PyObject *swig_obj[1] ;
5363   ldb_dn *result = 0 ;
5364
5365   if (!args) SWIG_fail;
5366   swig_obj[0] = args;
5367   res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ldb_context, 0 |  0 );
5368   if (!SWIG_IsOK(res1)) {
5369     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Ldb_get_default_basedn" "', argument " "1"" of type '" "ldb *""'");
5370   }
5371   arg1 = (ldb *)(argp1);
5372   if (arg1 == NULL)
5373   SWIG_exception(SWIG_ValueError,
5374     "ldb context must be non-NULL");
5375   result = (ldb_dn *)ldb_get_default_basedn(arg1);
5376   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ldb_dn, 0 |  0 );
5377   return resultobj;
5378 fail:
5379   return NULL;
5380 }
5381
5382
5383 SWIGINTERN PyObject *_wrap_Ldb_schema_format_value(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5384   PyObject *resultobj = 0;
5385   ldb *arg1 = (ldb *) 0 ;
5386   char *arg2 = (char *) 0 ;
5387   PyObject *arg3 = (PyObject *) 0 ;
5388   void *argp1 = 0 ;
5389   int res1 = 0 ;
5390   int res2 ;
5391   char *buf2 = 0 ;
5392   int alloc2 = 0 ;
5393   PyObject * obj0 = 0 ;
5394   PyObject * obj1 = 0 ;
5395   PyObject * obj2 = 0 ;
5396   char *  kwnames[] = {
5397     (char *) "self",(char *) "element_name",(char *) "val", NULL
5398   };
5399   PyObject *result = 0 ;
5400
5401   if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Ldb_schema_format_value",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
5402   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ldb_context, 0 |  0 );
5403   if (!SWIG_IsOK(res1)) {
5404     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Ldb_schema_format_value" "', argument " "1"" of type '" "ldb *""'");
5405   }
5406   arg1 = (ldb *)(argp1);
5407   res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
5408   if (!SWIG_IsOK(res2)) {
5409     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Ldb_schema_format_value" "', argument " "2"" of type '" "char const *""'");
5410   }
5411   arg2 = (char *)(buf2);
5412   arg3 = obj2;
5413   if (arg1 == NULL)
5414   SWIG_exception(SWIG_ValueError,
5415     "ldb context must be non-NULL");
5416   result = (PyObject *)ldb_schema_format_value(arg1,(char const *)arg2,arg3);
5417   resultobj = result;
5418   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
5419   return resultobj;
5420 fail:
5421   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
5422   return NULL;
5423 }
5424
5425
5426 SWIGINTERN PyObject *_wrap_Ldb_errstring(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5427   PyObject *resultobj = 0;
5428   ldb *arg1 = (ldb *) 0 ;
5429   void *argp1 = 0 ;
5430   int res1 = 0 ;
5431   PyObject *swig_obj[1] ;
5432   char *result = 0 ;
5433
5434   if (!args) SWIG_fail;
5435   swig_obj[0] = args;
5436   res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ldb_context, 0 |  0 );
5437   if (!SWIG_IsOK(res1)) {
5438     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Ldb_errstring" "', argument " "1"" of type '" "ldb *""'");
5439   }
5440   arg1 = (ldb *)(argp1);
5441   if (arg1 == NULL)
5442   SWIG_exception(SWIG_ValueError,
5443     "ldb context must be non-NULL");
5444   result = (char *)ldb_errstring(arg1);
5445   resultobj = SWIG_FromCharPtr((const char *)result);
5446   return resultobj;
5447 fail:
5448   return NULL;
5449 }
5450
5451
5452 SWIGINTERN PyObject *_wrap_Ldb_set_create_perms(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5453   PyObject *resultobj = 0;
5454   ldb *arg1 = (ldb *) 0 ;
5455   unsigned int arg2 ;
5456   void *argp1 = 0 ;
5457   int res1 = 0 ;
5458   unsigned int val2 ;
5459   int ecode2 = 0 ;
5460   PyObject * obj0 = 0 ;
5461   PyObject * obj1 = 0 ;
5462   char *  kwnames[] = {
5463     (char *) "self",(char *) "perms", NULL
5464   };
5465
5466   if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Ldb_set_create_perms",kwnames,&obj0,&obj1)) SWIG_fail;
5467   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ldb_context, 0 |  0 );
5468   if (!SWIG_IsOK(res1)) {
5469     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Ldb_set_create_perms" "', argument " "1"" of type '" "ldb *""'");
5470   }
5471   arg1 = (ldb *)(argp1);
5472   ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
5473   if (!SWIG_IsOK(ecode2)) {
5474     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Ldb_set_create_perms" "', argument " "2"" of type '" "unsigned int""'");
5475   }
5476   arg2 = (unsigned int)(val2);
5477   if (arg1 == NULL)
5478   SWIG_exception(SWIG_ValueError,
5479     "ldb context must be non-NULL");
5480   ldb_set_create_perms(arg1,arg2);
5481   resultobj = SWIG_Py_Void();
5482   return resultobj;
5483 fail:
5484   return NULL;
5485 }
5486
5487
5488 SWIGINTERN PyObject *_wrap_Ldb_set_modules_dir(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5489   PyObject *resultobj = 0;
5490   ldb *arg1 = (ldb *) 0 ;
5491   char *arg2 = (char *) 0 ;
5492   void *argp1 = 0 ;
5493   int res1 = 0 ;
5494   int res2 ;
5495   char *buf2 = 0 ;
5496   int alloc2 = 0 ;
5497   PyObject * obj0 = 0 ;
5498   PyObject * obj1 = 0 ;
5499   char *  kwnames[] = {
5500     (char *) "self",(char *) "path", NULL
5501   };
5502
5503   if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Ldb_set_modules_dir",kwnames,&obj0,&obj1)) SWIG_fail;
5504   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ldb_context, 0 |  0 );
5505   if (!SWIG_IsOK(res1)) {
5506     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Ldb_set_modules_dir" "', argument " "1"" of type '" "ldb *""'");
5507   }
5508   arg1 = (ldb *)(argp1);
5509   res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
5510   if (!SWIG_IsOK(res2)) {
5511     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Ldb_set_modules_dir" "', argument " "2"" of type '" "char const *""'");
5512   }
5513   arg2 = (char *)(buf2);
5514   if (arg1 == NULL)
5515   SWIG_exception(SWIG_ValueError,
5516     "ldb context must be non-NULL");
5517   ldb_set_modules_dir(arg1,(char const *)arg2);
5518   resultobj = SWIG_Py_Void();
5519   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
5520   return resultobj;
5521 fail:
5522   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
5523   return NULL;
5524 }
5525
5526
5527 SWIGINTERN PyObject *_wrap_Ldb_set_debug(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5528   PyObject *resultobj = 0;
5529   ldb *arg1 = (ldb *) 0 ;
5530   void (*arg2)(void *,enum ldb_debug_level,char const *,va_list) = (void (*)(void *,enum ldb_debug_level,char const *,va_list)) 0 ;
5531   void *arg3 = (void *) 0 ;
5532   void *argp1 = 0 ;
5533   int res1 = 0 ;
5534   PyObject * obj0 = 0 ;
5535   PyObject * obj1 = 0 ;
5536   char *  kwnames[] = {
5537     (char *) "self",(char *) "debug", NULL
5538   };
5539   ldb_error result;
5540
5541   if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Ldb_set_debug",kwnames,&obj0,&obj1)) SWIG_fail;
5542   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ldb_context, 0 |  0 );
5543   if (!SWIG_IsOK(res1)) {
5544     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Ldb_set_debug" "', argument " "1"" of type '" "ldb *""'");
5545   }
5546   arg1 = (ldb *)(argp1);
5547   arg2 = py_ldb_debug;
5548   /* FIXME: Should be decreased somewhere as well. Perhaps register a
5549          destructor and tie it to the ldb context ? */
5550   Py_INCREF(obj1);
5551   arg3 = obj1;
5552   if (arg1 == NULL)
5553   SWIG_exception(SWIG_ValueError,
5554     "ldb context must be non-NULL");
5555   result = ldb_set_debug(arg1,arg2,arg3);
5556   if (result != 0) {
5557     PyErr_SetObject(PyExc_LdbError, Py_BuildValue((char *)"(i,s)", result, ldb_errstring(arg1)));
5558     SWIG_fail;
5559   }
5560   resultobj = Py_None;
5561   return resultobj;
5562 fail:
5563   return NULL;
5564 }
5565
5566
5567 SWIGINTERN PyObject *_wrap_Ldb_set_opaque(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5568   PyObject *resultobj = 0;
5569   ldb *arg1 = (ldb *) 0 ;
5570   char *arg2 = (char *) 0 ;
5571   void *arg3 = (void *) 0 ;
5572   void *argp1 = 0 ;
5573   int res1 = 0 ;
5574   int res2 ;
5575   char *buf2 = 0 ;
5576   int alloc2 = 0 ;
5577   int res3 ;
5578   PyObject * obj0 = 0 ;
5579   PyObject * obj1 = 0 ;
5580   PyObject * obj2 = 0 ;
5581   char *  kwnames[] = {
5582     (char *) "self",(char *) "name",(char *) "value", NULL
5583   };
5584   ldb_error result;
5585
5586   if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Ldb_set_opaque",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
5587   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ldb_context, 0 |  0 );
5588   if (!SWIG_IsOK(res1)) {
5589     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Ldb_set_opaque" "', argument " "1"" of type '" "ldb *""'");
5590   }
5591   arg1 = (ldb *)(argp1);
5592   res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
5593   if (!SWIG_IsOK(res2)) {
5594     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Ldb_set_opaque" "', argument " "2"" of type '" "char const *""'");
5595   }
5596   arg2 = (char *)(buf2);
5597   res3 = SWIG_ConvertPtr(obj2,SWIG_as_voidptrptr(&arg3), 0, 0);
5598   if (!SWIG_IsOK(res3)) {
5599     SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Ldb_set_opaque" "', argument " "3"" of type '" "void *""'");
5600   }
5601   if (arg1 == NULL)
5602   SWIG_exception(SWIG_ValueError,
5603     "ldb context must be non-NULL");
5604   result = ldb_set_opaque(arg1,(char const *)arg2,arg3);
5605   if (result != 0) {
5606     PyErr_SetObject(PyExc_LdbError, Py_BuildValue((char *)"(i,s)", result, ldb_errstring(arg1)));
5607     SWIG_fail;
5608   }
5609   resultobj = Py_None;
5610   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
5611   return resultobj;
5612 fail:
5613   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
5614   return NULL;
5615 }
5616
5617
5618 SWIGINTERN PyObject *_wrap_Ldb_get_opaque(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5619   PyObject *resultobj = 0;
5620   ldb *arg1 = (ldb *) 0 ;
5621   char *arg2 = (char *) 0 ;
5622   void *argp1 = 0 ;
5623   int res1 = 0 ;
5624   int res2 ;
5625   char *buf2 = 0 ;
5626   int alloc2 = 0 ;
5627   PyObject * obj0 = 0 ;
5628   PyObject * obj1 = 0 ;
5629   char *  kwnames[] = {
5630     (char *) "self",(char *) "name", NULL
5631   };
5632   void *result = 0 ;
5633
5634   if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Ldb_get_opaque",kwnames,&obj0,&obj1)) SWIG_fail;
5635   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ldb_context, 0 |  0 );
5636   if (!SWIG_IsOK(res1)) {
5637     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Ldb_get_opaque" "', argument " "1"" of type '" "ldb *""'");
5638   }
5639   arg1 = (ldb *)(argp1);
5640   res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
5641   if (!SWIG_IsOK(res2)) {
5642     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Ldb_get_opaque" "', argument " "2"" of type '" "char const *""'");
5643   }
5644   arg2 = (char *)(buf2);
5645   if (arg1 == NULL)
5646   SWIG_exception(SWIG_ValueError,
5647     "ldb context must be non-NULL");
5648   result = (void *)ldb_get_opaque(arg1,(char const *)arg2);
5649   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 |  0 );
5650   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
5651   return resultobj;
5652 fail:
5653   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
5654   return NULL;
5655 }
5656
5657
5658 SWIGINTERN PyObject *_wrap_Ldb_transaction_start(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5659   PyObject *resultobj = 0;
5660   ldb *arg1 = (ldb *) 0 ;
5661   void *argp1 = 0 ;
5662   int res1 = 0 ;
5663   PyObject *swig_obj[1] ;
5664   ldb_error result;
5665
5666   if (!args) SWIG_fail;
5667   swig_obj[0] = args;
5668   res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ldb_context, 0 |  0 );
5669   if (!SWIG_IsOK(res1)) {
5670     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Ldb_transaction_start" "', argument " "1"" of type '" "ldb *""'");
5671   }
5672   arg1 = (ldb *)(argp1);
5673   if (arg1 == NULL)
5674   SWIG_exception(SWIG_ValueError,
5675     "ldb context must be non-NULL");
5676   result = ldb_transaction_start(arg1);
5677   if (result != 0) {
5678     PyErr_SetObject(PyExc_LdbError, Py_BuildValue((char *)"(i,s)", result, ldb_errstring(arg1)));
5679     SWIG_fail;
5680   }
5681   resultobj = Py_None;
5682   return resultobj;
5683 fail:
5684   return NULL;
5685 }
5686
5687
5688 SWIGINTERN PyObject *_wrap_Ldb_transaction_commit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5689   PyObject *resultobj = 0;
5690   ldb *arg1 = (ldb *) 0 ;
5691   void *argp1 = 0 ;
5692   int res1 = 0 ;
5693   PyObject *swig_obj[1] ;
5694   ldb_error result;
5695
5696   if (!args) SWIG_fail;
5697   swig_obj[0] = args;
5698   res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ldb_context, 0 |  0 );
5699   if (!SWIG_IsOK(res1)) {
5700     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Ldb_transaction_commit" "', argument " "1"" of type '" "ldb *""'");
5701   }
5702   arg1 = (ldb *)(argp1);
5703   if (arg1 == NULL)
5704   SWIG_exception(SWIG_ValueError,
5705     "ldb context must be non-NULL");
5706   result = ldb_transaction_commit(arg1);
5707   if (result != 0) {
5708     PyErr_SetObject(PyExc_LdbError, Py_BuildValue((char *)"(i,s)", result, ldb_errstring(arg1)));
5709     SWIG_fail;
5710   }
5711   resultobj = Py_None;
5712   return resultobj;
5713 fail:
5714   return NULL;
5715 }
5716
5717
5718 SWIGINTERN PyObject *_wrap_Ldb_transaction_cancel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5719   PyObject *resultobj = 0;
5720   ldb *arg1 = (ldb *) 0 ;
5721   void *argp1 = 0 ;
5722   int res1 = 0 ;
5723   PyObject *swig_obj[1] ;
5724   ldb_error result;
5725
5726   if (!args) SWIG_fail;
5727   swig_obj[0] = args;
5728   res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ldb_context, 0 |  0 );
5729   if (!SWIG_IsOK(res1)) {
5730     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Ldb_transaction_cancel" "', argument " "1"" of type '" "ldb *""'");
5731   }
5732   arg1 = (ldb *)(argp1);
5733   if (arg1 == NULL)
5734   SWIG_exception(SWIG_ValueError,
5735     "ldb context must be non-NULL");
5736   result = ldb_transaction_cancel(arg1);
5737   if (result != 0) {
5738     PyErr_SetObject(PyExc_LdbError, Py_BuildValue((char *)"(i,s)", result, ldb_errstring(arg1)));
5739     SWIG_fail;
5740   }
5741   resultobj = Py_None;
5742   return resultobj;
5743 fail:
5744   return NULL;
5745 }
5746
5747
5748 SWIGINTERN PyObject *_wrap_Ldb_schema_attribute_remove(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5749   PyObject *resultobj = 0;
5750   ldb *arg1 = (ldb *) 0 ;
5751   char *arg2 = (char *) 0 ;
5752   void *argp1 = 0 ;
5753   int res1 = 0 ;
5754   int res2 ;
5755   char *buf2 = 0 ;
5756   int alloc2 = 0 ;
5757   PyObject * obj0 = 0 ;
5758   PyObject * obj1 = 0 ;
5759   char *  kwnames[] = {
5760     (char *) "self",(char *) "name", NULL
5761   };
5762
5763   if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Ldb_schema_attribute_remove",kwnames,&obj0,&obj1)) SWIG_fail;
5764   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ldb_context, 0 |  0 );
5765   if (!SWIG_IsOK(res1)) {
5766     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Ldb_schema_attribute_remove" "', argument " "1"" of type '" "ldb *""'");
5767   }
5768   arg1 = (ldb *)(argp1);
5769   res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
5770   if (!SWIG_IsOK(res2)) {
5771     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Ldb_schema_attribute_remove" "', argument " "2"" of type '" "char const *""'");
5772   }
5773   arg2 = (char *)(buf2);
5774   if (arg1 == NULL)
5775   SWIG_exception(SWIG_ValueError,
5776     "ldb context must be non-NULL");
5777   ldb_schema_attribute_remove(arg1,(char const *)arg2);
5778   resultobj = SWIG_Py_Void();
5779   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
5780   return resultobj;
5781 fail:
5782   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
5783   return NULL;
5784 }
5785
5786
5787 SWIGINTERN PyObject *_wrap_Ldb_schema_attribute_add(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5788   PyObject *resultobj = 0;
5789   ldb *arg1 = (ldb *) 0 ;
5790   char *arg2 = (char *) 0 ;
5791   unsigned int arg3 ;
5792   char *arg4 = (char *) 0 ;
5793   void *argp1 = 0 ;
5794   int res1 = 0 ;
5795   int res2 ;
5796   char *buf2 = 0 ;
5797   int alloc2 = 0 ;
5798   unsigned int val3 ;
5799   int ecode3 = 0 ;
5800   int res4 ;
5801   char *buf4 = 0 ;
5802   int alloc4 = 0 ;
5803   PyObject * obj0 = 0 ;
5804   PyObject * obj1 = 0 ;
5805   PyObject * obj2 = 0 ;
5806   PyObject * obj3 = 0 ;
5807   char *  kwnames[] = {
5808     (char *) "self",(char *) "attribute",(char *) "flags",(char *) "syntax", NULL
5809   };
5810   ldb_error result;
5811
5812   if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Ldb_schema_attribute_add",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
5813   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ldb_context, 0 |  0 );
5814   if (!SWIG_IsOK(res1)) {
5815     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Ldb_schema_attribute_add" "', argument " "1"" of type '" "ldb *""'");
5816   }
5817   arg1 = (ldb *)(argp1);
5818   res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
5819   if (!SWIG_IsOK(res2)) {
5820     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Ldb_schema_attribute_add" "', argument " "2"" of type '" "char const *""'");
5821   }
5822   arg2 = (char *)(buf2);
5823   ecode3 = SWIG_AsVal_unsigned_SS_int(obj2, &val3);
5824   if (!SWIG_IsOK(ecode3)) {
5825     SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Ldb_schema_attribute_add" "', argument " "3"" of type '" "unsigned int""'");
5826   }
5827   arg3 = (unsigned int)(val3);
5828   res4 = SWIG_AsCharPtrAndSize(obj3, &buf4, NULL, &alloc4);
5829   if (!SWIG_IsOK(res4)) {
5830     SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Ldb_schema_attribute_add" "', argument " "4"" of type '" "char const *""'");
5831   }
5832   arg4 = (char *)(buf4);
5833   if (arg1 == NULL)
5834   SWIG_exception(SWIG_ValueError,
5835     "ldb context must be non-NULL");
5836   result = ldb_schema_attribute_add(arg1,(char const *)arg2,arg3,(char const *)arg4);
5837   if (result != 0) {
5838     PyErr_SetObject(PyExc_LdbError, Py_BuildValue((char *)"(i,s)", result, ldb_errstring(arg1)));
5839     SWIG_fail;
5840   }
5841   resultobj = Py_None;
5842   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
5843   if (alloc4 == SWIG_NEWOBJ) free((char*)buf4);
5844   return resultobj;
5845 fail:
5846   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
5847   if (alloc4 == SWIG_NEWOBJ) free((char*)buf4);
5848   return NULL;
5849 }
5850
5851
5852 SWIGINTERN PyObject *_wrap_Ldb_setup_wellknown_attributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5853   PyObject *resultobj = 0;
5854   ldb *arg1 = (ldb *) 0 ;
5855   void *argp1 = 0 ;
5856   int res1 = 0 ;
5857   PyObject *swig_obj[1] ;
5858   ldb_error result;
5859
5860   if (!args) SWIG_fail;
5861   swig_obj[0] = args;
5862   res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ldb_context, 0 |  0 );
5863   if (!SWIG_IsOK(res1)) {
5864     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Ldb_setup_wellknown_attributes" "', argument " "1"" of type '" "ldb *""'");
5865   }
5866   arg1 = (ldb *)(argp1);
5867   if (arg1 == NULL)
5868   SWIG_exception(SWIG_ValueError,
5869     "ldb context must be non-NULL");
5870   result = ldb_setup_wellknown_attributes(arg1);
5871   if (result != 0) {
5872     PyErr_SetObject(PyExc_LdbError, Py_BuildValue((char *)"(i,s)", result, ldb_errstring(arg1)));
5873     SWIG_fail;
5874   }
5875   resultobj = Py_None;
5876   return resultobj;
5877 fail:
5878   return NULL;
5879 }
5880
5881
5882 SWIGINTERN PyObject *_wrap_Ldb___contains__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5883   PyObject *resultobj = 0;
5884   ldb *arg1 = (ldb *) 0 ;
5885   ldb_dn *arg2 = (ldb_dn *) 0 ;
5886   struct ldb_result **arg3 = (struct ldb_result **) 0 ;
5887   void *argp1 = 0 ;
5888   int res1 = 0 ;
5889   struct ldb_result *tmp3 ;
5890   PyObject * obj0 = 0 ;
5891   PyObject * obj1 = 0 ;
5892   char *  kwnames[] = {
5893     (char *) "self",(char *) "dn", NULL
5894   };
5895   ldb_error result;
5896
5897   arg3 = &tmp3;
5898   if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Ldb___contains__",kwnames,&obj0,&obj1)) SWIG_fail;
5899   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ldb_context, 0 |  0 );
5900   if (!SWIG_IsOK(res1)) {
5901     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Ldb___contains__" "', argument " "1"" of type '" "ldb *""'");
5902   }
5903   arg1 = (ldb *)(argp1);
5904   if (ldb_dn_from_pyobject(NULL, obj1, arg1, &arg2) != 0) {
5905     SWIG_fail;
5906   }
5907   if (arg1 == NULL)
5908   SWIG_exception(SWIG_ValueError,
5909     "ldb context must be non-NULL");
5910   result = ldb___contains__(arg1,arg2,arg3);
5911   if (result != 0) {
5912     PyErr_SetObject(PyExc_LdbError, Py_BuildValue((char *)"(i,s)", result, ldb_errstring(arg1)));
5913     SWIG_fail;
5914   }
5915   resultobj = Py_None;
5916   resultobj = ((*arg3)->count > 0)?Py_True:Py_False;
5917   talloc_free(arg2);
5918   talloc_free(*arg3);
5919   return resultobj;
5920 fail:
5921   talloc_free(arg2);
5922   talloc_free(*arg3);
5923   return NULL;
5924 }
5925
5926
5927 SWIGINTERN PyObject *_wrap_Ldb_parse_ldif(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5928   PyObject *resultobj = 0;
5929   ldb *arg1 = (ldb *) 0 ;
5930   char *arg2 = (char *) 0 ;
5931   void *argp1 = 0 ;
5932   int res1 = 0 ;
5933   int res2 ;
5934   char *buf2 = 0 ;
5935   int alloc2 = 0 ;
5936   PyObject * obj0 = 0 ;
5937   PyObject * obj1 = 0 ;
5938   char *  kwnames[] = {
5939     (char *) "self",(char *) "s", NULL
5940   };
5941   PyObject *result = 0 ;
5942
5943   if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Ldb_parse_ldif",kwnames,&obj0,&obj1)) SWIG_fail;
5944   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ldb_context, 0 |  0 );
5945   if (!SWIG_IsOK(res1)) {
5946     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Ldb_parse_ldif" "', argument " "1"" of type '" "ldb *""'");
5947   }
5948   arg1 = (ldb *)(argp1);
5949   res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
5950   if (!SWIG_IsOK(res2)) {
5951     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Ldb_parse_ldif" "', argument " "2"" of type '" "char const *""'");
5952   }
5953   arg2 = (char *)(buf2);
5954   if (arg1 == NULL)
5955   SWIG_exception(SWIG_ValueError,
5956     "ldb context must be non-NULL");
5957   result = (PyObject *)ldb_parse_ldif(arg1,(char const *)arg2);
5958   resultobj = result;
5959   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
5960   return resultobj;
5961 fail:
5962   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
5963   return NULL;
5964 }
5965
5966
5967 SWIGINTERN PyObject *_wrap_Ldb___repr__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5968   PyObject *resultobj = 0;
5969   ldb *arg1 = (ldb *) 0 ;
5970   void *argp1 = 0 ;
5971   int res1 = 0 ;
5972   PyObject *swig_obj[1] ;
5973   char *result = 0 ;
5974
5975   if (!args) SWIG_fail;
5976   swig_obj[0] = args;
5977   res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ldb_context, 0 |  0 );
5978   if (!SWIG_IsOK(res1)) {
5979     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Ldb___repr__" "', argument " "1"" of type '" "ldb *""'");
5980   }
5981   arg1 = (ldb *)(argp1);
5982   if (arg1 == NULL)
5983   SWIG_exception(SWIG_ValueError,
5984     "ldb context must be non-NULL");
5985   result = (char *)ldb___repr__(arg1);
5986   resultobj = SWIG_FromCharPtr((const char *)result);
5987   return resultobj;
5988 fail:
5989   return NULL;
5990 }
5991
5992
5993 SWIGINTERN PyObject *Ldb_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5994   PyObject *obj;
5995   if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
5996   SWIG_TypeNewClientData(SWIGTYPE_p_ldb_context, SWIG_NewClientData(obj));
5997   return SWIG_Py_Void();
5998 }
5999
6000 SWIGINTERN PyObject *Ldb_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6001   return SWIG_Python_InitShadowInstance(args);
6002 }
6003
6004 SWIGINTERN PyObject *_wrap_valid_attr_name(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6005   PyObject *resultobj = 0;
6006   char *arg1 = (char *) 0 ;
6007   int res1 ;
6008   char *buf1 = 0 ;
6009   int alloc1 = 0 ;
6010   PyObject * obj0 = 0 ;
6011   char *  kwnames[] = {
6012     (char *) "s", NULL
6013   };
6014   int result;
6015
6016   if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:valid_attr_name",kwnames,&obj0)) SWIG_fail;
6017   res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
6018   if (!SWIG_IsOK(res1)) {
6019     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "valid_attr_name" "', argument " "1"" of type '" "char const *""'");
6020   }
6021   arg1 = (char *)(buf1);
6022   result = (int)ldb_valid_attr_name((char const *)arg1);
6023   resultobj = SWIG_From_int((int)(result));
6024   if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
6025   return resultobj;
6026 fail:
6027   if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
6028   return NULL;
6029 }
6030
6031
6032 SWIGINTERN PyObject *_wrap_timestring(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6033   PyObject *resultobj = 0;
6034   time_t arg1 ;
6035   unsigned long val1 ;
6036   int ecode1 = 0 ;
6037   PyObject * obj0 = 0 ;
6038   char *  kwnames[] = {
6039     (char *) "t", NULL
6040   };
6041   char *result = 0 ;
6042
6043   if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:timestring",kwnames,&obj0)) SWIG_fail;
6044   ecode1 = SWIG_AsVal_unsigned_SS_long(obj0, &val1);
6045   if (!SWIG_IsOK(ecode1)) {
6046     SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "timestring" "', argument " "1"" of type '" "time_t""'");
6047   }
6048   arg1 = (time_t)(val1);
6049   result = (char *)timestring(arg1);
6050   resultobj = SWIG_FromCharPtr((const char *)result);
6051   return resultobj;
6052 fail:
6053   return NULL;
6054 }
6055
6056
6057 SWIGINTERN PyObject *_wrap_string_to_time(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6058   PyObject *resultobj = 0;
6059   char *arg1 = (char *) 0 ;
6060   int res1 ;
6061   char *buf1 = 0 ;
6062   int alloc1 = 0 ;
6063   PyObject * obj0 = 0 ;
6064   char *  kwnames[] = {
6065     (char *) "s", NULL
6066   };
6067   time_t result;
6068
6069   if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:string_to_time",kwnames,&obj0)) SWIG_fail;
6070   res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
6071   if (!SWIG_IsOK(res1)) {
6072     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "string_to_time" "', argument " "1"" of type '" "char const *""'");
6073   }
6074   arg1 = (char *)(buf1);
6075   result = (time_t)ldb_string_to_time((char const *)arg1);
6076   resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
6077   if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
6078   return resultobj;
6079 fail:
6080   if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
6081   return NULL;
6082 }
6083
6084
6085 SWIGINTERN PyObject *_wrap_ldb_module_prev_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6086   PyObject *resultobj = 0;
6087   ldb_module *arg1 = (ldb_module *) 0 ;
6088   struct ldb_module *arg2 = (struct ldb_module *) 0 ;
6089   void *argp1 = 0 ;
6090   int res1 = 0 ;
6091   void *argp2 = 0 ;
6092   int res2 = 0 ;
6093   PyObject *swig_obj[2] ;
6094
6095   if (!SWIG_Python_UnpackTuple(args,"ldb_module_prev_set",2,2,swig_obj)) SWIG_fail;
6096   res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ldb_module, 0 |  0 );
6097   if (!SWIG_IsOK(res1)) {
6098     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ldb_module_prev_set" "', argument " "1"" of type '" "ldb_module *""'");
6099   }
6100   arg1 = (ldb_module *)(argp1);
6101   res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_ldb_module, SWIG_POINTER_DISOWN |  0 );
6102   if (!SWIG_IsOK(res2)) {
6103     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ldb_module_prev_set" "', argument " "2"" of type '" "struct ldb_module *""'");
6104   }
6105   arg2 = (struct ldb_module *)(argp2);
6106   if (arg1) (arg1)->prev = arg2;
6107   resultobj = SWIG_Py_Void();
6108   return resultobj;
6109 fail:
6110   return NULL;
6111 }
6112
6113
6114 SWIGINTERN PyObject *_wrap_ldb_module_prev_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6115   PyObject *resultobj = 0;
6116   ldb_module *arg1 = (ldb_module *) 0 ;
6117   void *argp1 = 0 ;
6118   int res1 = 0 ;
6119   PyObject *swig_obj[1] ;
6120   struct ldb_module *result = 0 ;
6121
6122   if (!args) SWIG_fail;
6123   swig_obj[0] = args;
6124   res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ldb_module, 0 |  0 );
6125   if (!SWIG_IsOK(res1)) {
6126     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ldb_module_prev_get" "', argument " "1"" of type '" "ldb_module *""'");
6127   }
6128   arg1 = (ldb_module *)(argp1);
6129   result = (struct ldb_module *) ((arg1)->prev);
6130   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ldb_module, 0 |  0 );
6131   return resultobj;
6132 fail:
6133   return NULL;
6134 }
6135
6136
6137 SWIGINTERN PyObject *_wrap_ldb_module_next_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6138   PyObject *resultobj = 0;
6139   ldb_module *arg1 = (ldb_module *) 0 ;
6140   struct ldb_module *arg2 = (struct ldb_module *) 0 ;
6141   void *argp1 = 0 ;
6142   int res1 = 0 ;
6143   void *argp2 = 0 ;
6144   int res2 = 0 ;
6145   PyObject *swig_obj[2] ;
6146
6147   if (!SWIG_Python_UnpackTuple(args,"ldb_module_next_set",2,2,swig_obj)) SWIG_fail;
6148   res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ldb_module, 0 |  0 );
6149   if (!SWIG_IsOK(res1)) {
6150     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ldb_module_next_set" "', argument " "1"" of type '" "ldb_module *""'");
6151   }
6152   arg1 = (ldb_module *)(argp1);
6153   res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_ldb_module, SWIG_POINTER_DISOWN |  0 );
6154   if (!SWIG_IsOK(res2)) {
6155     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ldb_module_next_set" "', argument " "2"" of type '" "struct ldb_module *""'");
6156   }
6157   arg2 = (struct ldb_module *)(argp2);
6158   if (arg1) (arg1)->next = arg2;
6159   resultobj = SWIG_Py_Void();
6160   return resultobj;
6161 fail:
6162   return NULL;
6163 }
6164
6165
6166 SWIGINTERN PyObject *_wrap_ldb_module_next_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6167   PyObject *resultobj = 0;
6168   ldb_module *arg1 = (ldb_module *) 0 ;
6169   void *argp1 = 0 ;
6170   int res1 = 0 ;
6171   PyObject *swig_obj[1] ;
6172   struct ldb_module *result = 0 ;
6173
6174   if (!args) SWIG_fail;
6175   swig_obj[0] = args;
6176   res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ldb_module, 0 |  0 );
6177   if (!SWIG_IsOK(res1)) {
6178     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ldb_module_next_get" "', argument " "1"" of type '" "ldb_module *""'");
6179   }
6180   arg1 = (ldb_module *)(argp1);
6181   result = (struct ldb_module *) ((arg1)->next);
6182   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ldb_module, 0 |  0 );
6183   return resultobj;
6184 fail:
6185   return NULL;
6186 }
6187
6188
6189 SWIGINTERN PyObject *_wrap_ldb_module___str__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6190   PyObject *resultobj = 0;
6191   ldb_module *arg1 = (ldb_module *) 0 ;
6192   void *argp1 = 0 ;
6193   int res1 = 0 ;
6194   PyObject *swig_obj[1] ;
6195   char *result = 0 ;
6196
6197   if (!args) SWIG_fail;
6198   swig_obj[0] = args;
6199   res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ldb_module, 0 |  0 );
6200   if (!SWIG_IsOK(res1)) {
6201     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ldb_module___str__" "', argument " "1"" of type '" "ldb_module *""'");
6202   }
6203   arg1 = (ldb_module *)(argp1);
6204   result = (char *)ldb_module___str__(arg1);
6205   resultobj = SWIG_FromCharPtr((const char *)result);
6206   return resultobj;
6207 fail:
6208   return NULL;
6209 }
6210
6211
6212 SWIGINTERN PyObject *_wrap_ldb_module___repr__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6213   PyObject *resultobj = 0;
6214   ldb_module *arg1 = (ldb_module *) 0 ;
6215   void *argp1 = 0 ;
6216   int res1 = 0 ;
6217   PyObject *swig_obj[1] ;
6218   char *result = 0 ;
6219
6220   if (!args) SWIG_fail;
6221   swig_obj[0] = args;
6222   res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ldb_module, 0 |  0 );
6223   if (!SWIG_IsOK(res1)) {
6224     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ldb_module___repr__" "', argument " "1"" of type '" "ldb_module *""'");
6225   }
6226   arg1 = (ldb_module *)(argp1);
6227   result = (char *)ldb_module___repr__(arg1);
6228   resultobj = SWIG_FromCharPtr((const char *)result);
6229   return resultobj;
6230 fail:
6231   return NULL;
6232 }
6233
6234
6235 SWIGINTERN PyObject *_wrap_ldb_module_search(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6236   PyObject *resultobj = 0;
6237   ldb_module *arg1 = (ldb_module *) 0 ;
6238   struct ldb_request *arg2 = (struct ldb_request *) 0 ;
6239   void *argp1 = 0 ;
6240   int res1 = 0 ;
6241   void *argp2 = 0 ;
6242   int res2 = 0 ;
6243   PyObject * obj0 = 0 ;
6244   PyObject * obj1 = 0 ;
6245   char *  kwnames[] = {
6246     (char *) "self",(char *) "req", NULL
6247   };
6248   int result;
6249
6250   if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ldb_module_search",kwnames,&obj0,&obj1)) SWIG_fail;
6251   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ldb_module, 0 |  0 );
6252   if (!SWIG_IsOK(res1)) {
6253     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ldb_module_search" "', argument " "1"" of type '" "ldb_module *""'");
6254   }
6255   arg1 = (ldb_module *)(argp1);
6256   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_ldb_request, 0 |  0 );
6257   if (!SWIG_IsOK(res2)) {
6258     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ldb_module_search" "', argument " "2"" of type '" "struct ldb_request *""'");
6259   }
6260   arg2 = (struct ldb_request *)(argp2);
6261   result = (int)ldb_module_search(arg1,arg2);
6262   resultobj = SWIG_From_int((int)(result));
6263   return resultobj;
6264 fail:
6265   return NULL;
6266 }
6267
6268
6269 SWIGINTERN PyObject *_wrap_ldb_module_add(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6270   PyObject *resultobj = 0;
6271   ldb_module *arg1 = (ldb_module *) 0 ;
6272   struct ldb_request *arg2 = (struct ldb_request *) 0 ;
6273   void *argp1 = 0 ;
6274   int res1 = 0 ;
6275   void *argp2 = 0 ;
6276   int res2 = 0 ;
6277   PyObject * obj0 = 0 ;
6278   PyObject * obj1 = 0 ;
6279   char *  kwnames[] = {
6280     (char *) "self",(char *) "req", NULL
6281   };
6282   ldb_error result;
6283
6284   if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ldb_module_add",kwnames,&obj0,&obj1)) 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_add" "', argument " "1"" of type '" "ldb_module *""'");
6288   }
6289   arg1 = (ldb_module *)(argp1);
6290   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_ldb_request, 0 |  0 );
6291   if (!SWIG_IsOK(res2)) {
6292     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ldb_module_add" "', argument " "2"" of type '" "struct ldb_request *""'");
6293   }
6294   arg2 = (struct ldb_request *)(argp2);
6295   result = ldb_module_add(arg1,arg2);
6296   if (result != 0) {
6297     PyErr_SetObject(PyExc_LdbError, Py_BuildValue((char *)"(i,s)", result, ldb_errstring(arg1)));
6298     SWIG_fail;
6299   }
6300   resultobj = Py_None;
6301   return resultobj;
6302 fail:
6303   return NULL;
6304 }
6305
6306
6307 SWIGINTERN PyObject *_wrap_ldb_module_modify(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6308   PyObject *resultobj = 0;
6309   ldb_module *arg1 = (ldb_module *) 0 ;
6310   struct ldb_request *arg2 = (struct ldb_request *) 0 ;
6311   void *argp1 = 0 ;
6312   int res1 = 0 ;
6313   void *argp2 = 0 ;
6314   int res2 = 0 ;
6315   PyObject * obj0 = 0 ;
6316   PyObject * obj1 = 0 ;
6317   char *  kwnames[] = {
6318     (char *) "self",(char *) "req", NULL
6319   };
6320   ldb_error result;
6321
6322   if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ldb_module_modify",kwnames,&obj0,&obj1)) SWIG_fail;
6323   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ldb_module, 0 |  0 );
6324   if (!SWIG_IsOK(res1)) {
6325     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ldb_module_modify" "', argument " "1"" of type '" "ldb_module *""'");
6326   }
6327   arg1 = (ldb_module *)(argp1);
6328   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_ldb_request, 0 |  0 );
6329   if (!SWIG_IsOK(res2)) {
6330     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ldb_module_modify" "', argument " "2"" of type '" "struct ldb_request *""'");
6331   }
6332   arg2 = (struct ldb_request *)(argp2);
6333   result = ldb_module_modify(arg1,arg2);
6334   if (result != 0) {
6335     PyErr_SetObject(PyExc_LdbError, Py_BuildValue((char *)"(i,s)", result, ldb_errstring(arg1)));
6336     SWIG_fail;
6337   }
6338   resultobj = Py_None;
6339   return resultobj;
6340 fail:
6341   return NULL;
6342 }
6343
6344
6345 SWIGINTERN PyObject *_wrap_ldb_module_delete(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6346   PyObject *resultobj = 0;
6347   ldb_module *arg1 = (ldb_module *) 0 ;
6348   struct ldb_request *arg2 = (struct ldb_request *) 0 ;
6349   void *argp1 = 0 ;
6350   int res1 = 0 ;
6351   void *argp2 = 0 ;
6352   int res2 = 0 ;
6353   PyObject * obj0 = 0 ;
6354   PyObject * obj1 = 0 ;
6355   char *  kwnames[] = {
6356     (char *) "self",(char *) "req", NULL
6357   };
6358   ldb_error result;
6359
6360   if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ldb_module_delete",kwnames,&obj0,&obj1)) SWIG_fail;
6361   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ldb_module, 0 |  0 );
6362   if (!SWIG_IsOK(res1)) {
6363     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ldb_module_delete" "', argument " "1"" of type '" "ldb_module *""'");
6364   }
6365   arg1 = (ldb_module *)(argp1);
6366   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_ldb_request, 0 |  0 );
6367   if (!SWIG_IsOK(res2)) {
6368     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ldb_module_delete" "', argument " "2"" of type '" "struct ldb_request *""'");
6369   }
6370   arg2 = (struct ldb_request *)(argp2);
6371   result = ldb_module_delete(arg1,arg2);
6372   if (result != 0) {
6373     PyErr_SetObject(PyExc_LdbError, Py_BuildValue((char *)"(i,s)", result, ldb_errstring(arg1)));
6374     SWIG_fail;
6375   }
6376   resultobj = Py_None;
6377   return resultobj;
6378 fail:
6379   return NULL;
6380 }
6381
6382
6383 SWIGINTERN PyObject *_wrap_ldb_module_rename(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6384   PyObject *resultobj = 0;
6385   ldb_module *arg1 = (ldb_module *) 0 ;
6386   struct ldb_request *arg2 = (struct ldb_request *) 0 ;
6387   void *argp1 = 0 ;
6388   int res1 = 0 ;
6389   void *argp2 = 0 ;
6390   int res2 = 0 ;
6391   PyObject * obj0 = 0 ;
6392   PyObject * obj1 = 0 ;
6393   char *  kwnames[] = {
6394     (char *) "self",(char *) "req", NULL
6395   };
6396   ldb_error result;
6397
6398   if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ldb_module_rename",kwnames,&obj0,&obj1)) SWIG_fail;
6399   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ldb_module, 0 |  0 );
6400   if (!SWIG_IsOK(res1)) {
6401     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ldb_module_rename" "', argument " "1"" of type '" "ldb_module *""'");
6402   }
6403   arg1 = (ldb_module *)(argp1);
6404   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_ldb_request, 0 |  0 );
6405   if (!SWIG_IsOK(res2)) {
6406     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ldb_module_rename" "', argument " "2"" of type '" "struct ldb_request *""'");
6407   }
6408   arg2 = (struct ldb_request *)(argp2);
6409   result = ldb_module_rename(arg1,arg2);
6410   if (result != 0) {
6411     PyErr_SetObject(PyExc_LdbError, Py_BuildValue((char *)"(i,s)", result, ldb_errstring(arg1)));
6412     SWIG_fail;
6413   }
6414   resultobj = Py_None;
6415   return resultobj;
6416 fail:
6417   return NULL;
6418 }
6419
6420
6421 SWIGINTERN PyObject *_wrap_ldb_module_start_transaction(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6422   PyObject *resultobj = 0;
6423   ldb_module *arg1 = (ldb_module *) 0 ;
6424   void *argp1 = 0 ;
6425   int res1 = 0 ;
6426   PyObject *swig_obj[1] ;
6427   ldb_error result;
6428
6429   if (!args) SWIG_fail;
6430   swig_obj[0] = args;
6431   res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ldb_module, 0 |  0 );
6432   if (!SWIG_IsOK(res1)) {
6433     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ldb_module_start_transaction" "', argument " "1"" of type '" "ldb_module *""'");
6434   }
6435   arg1 = (ldb_module *)(argp1);
6436   result = ldb_module_start_transaction(arg1);
6437   if (result != 0) {
6438     PyErr_SetObject(PyExc_LdbError, Py_BuildValue((char *)"(i,s)", result, ldb_errstring(arg1)));
6439     SWIG_fail;
6440   }
6441   resultobj = Py_None;
6442   return resultobj;
6443 fail:
6444   return NULL;
6445 }
6446
6447
6448 SWIGINTERN PyObject *_wrap_ldb_module_end_transaction(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6449   PyObject *resultobj = 0;
6450   ldb_module *arg1 = (ldb_module *) 0 ;
6451   void *argp1 = 0 ;
6452   int res1 = 0 ;
6453   PyObject *swig_obj[1] ;
6454   ldb_error result;
6455
6456   if (!args) SWIG_fail;
6457   swig_obj[0] = args;
6458   res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ldb_module, 0 |  0 );
6459   if (!SWIG_IsOK(res1)) {
6460     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ldb_module_end_transaction" "', argument " "1"" of type '" "ldb_module *""'");
6461   }
6462   arg1 = (ldb_module *)(argp1);
6463   result = ldb_module_end_transaction(arg1);
6464   if (result != 0) {
6465     PyErr_SetObject(PyExc_LdbError, Py_BuildValue((char *)"(i,s)", result, ldb_errstring(arg1)));
6466     SWIG_fail;
6467   }
6468   resultobj = Py_None;
6469   return resultobj;
6470 fail:
6471   return NULL;
6472 }
6473
6474
6475 SWIGINTERN PyObject *_wrap_ldb_module_del_transaction(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6476   PyObject *resultobj = 0;
6477   ldb_module *arg1 = (ldb_module *) 0 ;
6478   void *argp1 = 0 ;
6479   int res1 = 0 ;
6480   PyObject *swig_obj[1] ;
6481   ldb_error result;
6482
6483   if (!args) SWIG_fail;
6484   swig_obj[0] = args;
6485   res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ldb_module, 0 |  0 );
6486   if (!SWIG_IsOK(res1)) {
6487     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ldb_module_del_transaction" "', argument " "1"" of type '" "ldb_module *""'");
6488   }
6489   arg1 = (ldb_module *)(argp1);
6490   result = ldb_module_del_transaction(arg1);
6491   if (result != 0) {
6492     PyErr_SetObject(PyExc_LdbError, Py_BuildValue((char *)"(i,s)", result, ldb_errstring(arg1)));
6493     SWIG_fail;
6494   }
6495   resultobj = Py_None;
6496   return resultobj;
6497 fail:
6498   return NULL;
6499 }
6500
6501
6502 SWIGINTERN PyObject *_wrap_new_ldb_module(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6503   PyObject *resultobj = 0;
6504   ldb_module *result = 0 ;
6505
6506   if (!SWIG_Python_UnpackTuple(args,"new_ldb_module",0,0,0)) SWIG_fail;
6507   result = (ldb_module *)calloc(1, sizeof(ldb_module));
6508   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ldb_module, SWIG_POINTER_NEW |  0 );
6509   return resultobj;
6510 fail:
6511   return NULL;
6512 }
6513
6514
6515 SWIGINTERN PyObject *_wrap_delete_ldb_module(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6516   PyObject *resultobj = 0;
6517   ldb_module *arg1 = (ldb_module *) 0 ;
6518   void *argp1 = 0 ;
6519   int res1 = 0 ;
6520   PyObject *swig_obj[1] ;
6521
6522   if (!args) SWIG_fail;
6523   swig_obj[0] = args;
6524   res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ldb_module, SWIG_POINTER_DISOWN |  0 );
6525   if (!SWIG_IsOK(res1)) {
6526     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ldb_module" "', argument " "1"" of type '" "ldb_module *""'");
6527   }
6528   arg1 = (ldb_module *)(argp1);
6529   free((char *) arg1);
6530   resultobj = SWIG_Py_Void();
6531   return resultobj;
6532 fail:
6533   return NULL;
6534 }
6535
6536
6537 SWIGINTERN PyObject *ldb_module_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6538   PyObject *obj;
6539   if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
6540   SWIG_TypeNewClientData(SWIGTYPE_p_ldb_module, SWIG_NewClientData(obj));
6541   return SWIG_Py_Void();
6542 }
6543
6544 SWIGINTERN PyObject *ldb_module_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6545   return SWIG_Python_InitShadowInstance(args);
6546 }
6547
6548 SWIGINTERN PyObject *_wrap_register_module(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6549   PyObject *resultobj = 0;
6550   struct ldb_module_ops *arg1 = (struct ldb_module_ops *) 0 ;
6551   PyObject * obj0 = 0 ;
6552   char *  kwnames[] = {
6553     (char *)"arg1", NULL
6554   };
6555   ldb_int_error result;
6556
6557   if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:register_module",kwnames,&obj0)) SWIG_fail;
6558   arg1 = talloc_zero(talloc_autofree_context(), struct ldb_module_ops);
6559
6560   arg1->name = talloc_strdup(arg1, PyString_AsString(PyObject_GetAttrString(obj0, (char *)"name")));
6561
6562   Py_INCREF(obj0);
6563   arg1->private_data = obj0;
6564   arg1->init_context = py_module_init;
6565   arg1->search = py_module_search;
6566   arg1->add = py_module_add;
6567   arg1->modify = py_module_modify;
6568   arg1->del = py_module_del;
6569   arg1->rename = py_module_rename;
6570   arg1->request = py_module_request;
6571   arg1->extended = py_module_extended;
6572   arg1->start_transaction = py_module_start_transaction;
6573   arg1->end_transaction = py_module_end_transaction;
6574   arg1->del_transaction = py_module_del_transaction;
6575   arg1->wait = py_module_wait;
6576   arg1->sequence_number = py_module_sequence_number;
6577   result = ldb_register_module((struct ldb_module_ops const *)arg1);
6578   if (result != 0) {
6579     PyErr_SetObject(PyExc_LdbError, Py_BuildValue((char *)"(i,s)", result, ldb_strerror(result)));
6580     SWIG_fail;
6581   }
6582   resultobj = Py_None;
6583   return resultobj;
6584 fail:
6585   return NULL;
6586 }
6587
6588
6589 static PyMethodDef SwigMethods[] = {
6590          { (char *)"ldb_val_to_py_object", (PyCFunction) _wrap_ldb_val_to_py_object, METH_VARARGS | METH_KEYWORDS, NULL},
6591          { (char *)"new_Dn", (PyCFunction) _wrap_new_Dn, METH_VARARGS | METH_KEYWORDS, (char *)"\n"
6592                 "S.__init__(ldb, string)\n"
6593                 "Create a new DN.\n"
6594                 ""},
6595          { (char *)"delete_Dn", (PyCFunction)_wrap_delete_Dn, METH_O, NULL},
6596          { (char *)"Dn_validate", (PyCFunction)_wrap_Dn_validate, METH_O, (char *)"\n"
6597                 "S.validate() -> bool\n"
6598                 "Validate DN is correct.\n"
6599                 ""},
6600          { (char *)"Dn_get_casefold", (PyCFunction)_wrap_Dn_get_casefold, METH_O, NULL},
6601          { (char *)"Dn___str__", (PyCFunction)_wrap_Dn___str__, METH_O, NULL},
6602          { (char *)"Dn_parent", (PyCFunction)_wrap_Dn_parent, METH_O, (char *)"\n"
6603                 "S.parent() -> dn\n"
6604                 "Get the parent for this DN.\n"
6605                 ""},
6606          { (char *)"Dn___cmp__", (PyCFunction) _wrap_Dn___cmp__, METH_VARARGS | METH_KEYWORDS, NULL},
6607          { (char *)"Dn_is_valid", (PyCFunction)_wrap_Dn_is_valid, METH_O, NULL},
6608          { (char *)"Dn_is_special", (PyCFunction)_wrap_Dn_is_special, METH_O, (char *)"\n"
6609                 "S.is_special() -> bool\n"
6610                 "Check whether this is a special LDB DN.\n"
6611                 ""},
6612          { (char *)"Dn_is_null", (PyCFunction)_wrap_Dn_is_null, METH_O, (char *)"\n"
6613                 "S.is_null() -> bool\n"
6614                 "Check whether this is a null DN.\n"
6615                 ""},
6616          { (char *)"Dn_check_special", (PyCFunction) _wrap_Dn_check_special, METH_VARARGS | METH_KEYWORDS, NULL},
6617          { (char *)"Dn___len__", (PyCFunction)_wrap_Dn___len__, METH_O, NULL},
6618          { (char *)"Dn_add_child", (PyCFunction) _wrap_Dn_add_child, METH_VARARGS | METH_KEYWORDS, (char *)"\n"
6619                 "S.add_child(dn) -> None\n"
6620                 "Add a child DN to this DN.\n"
6621                 ""},
6622          { (char *)"Dn_add_base", (PyCFunction) _wrap_Dn_add_base, METH_VARARGS | METH_KEYWORDS, (char *)"\n"
6623                 "S.add_base(dn) -> None\n"
6624                 "Add a base DN to this DN.\n"
6625                 ""},
6626          { (char *)"Dn_canonical_str", (PyCFunction)_wrap_Dn_canonical_str, METH_O, (char *)"\n"
6627                 "S.canonical_str() -> string\n"
6628                 "Canonical version of this DN (like a posix path).\n"
6629                 ""},
6630          { (char *)"Dn_canonical_ex_str", (PyCFunction)_wrap_Dn_canonical_ex_str, METH_O, (char *)"\n"
6631                 "S.canonical_ex_str() -> string\n"
6632                 "Canonical version of this DN (like a posix path, with terminating newline).\n"
6633                 ""},
6634          { (char *)"Dn___repr__", (PyCFunction)_wrap_Dn___repr__, METH_O, NULL},
6635          { (char *)"Dn___add__", (PyCFunction) _wrap_Dn___add__, METH_VARARGS | METH_KEYWORDS, NULL},
6636          { (char *)"Dn_swigregister", Dn_swigregister, METH_VARARGS, NULL},
6637          { (char *)"Dn_swiginit", Dn_swiginit, METH_VARARGS, NULL},
6638          { (char *)"MessageElement___cmp__", (PyCFunction) _wrap_MessageElement___cmp__, METH_VARARGS | METH_KEYWORDS, NULL},
6639          { (char *)"MessageElement___iter__", (PyCFunction)_wrap_MessageElement___iter__, METH_O, NULL},
6640          { (char *)"MessageElement___set__", (PyCFunction)_wrap_MessageElement___set__, METH_O, NULL},
6641          { (char *)"new_MessageElement", (PyCFunction) _wrap_new_MessageElement, METH_VARARGS | METH_KEYWORDS, (char *)"Message element."},
6642          { (char *)"MessageElement___len__", (PyCFunction)_wrap_MessageElement___len__, METH_O, NULL},
6643          { (char *)"MessageElement_get", (PyCFunction) _wrap_MessageElement_get, METH_VARARGS | METH_KEYWORDS, NULL},
6644          { (char *)"delete_MessageElement", (PyCFunction)_wrap_delete_MessageElement, METH_O, NULL},
6645          { (char *)"MessageElement_swigregister", MessageElement_swigregister, METH_VARARGS, NULL},
6646          { (char *)"MessageElement_swiginit", MessageElement_swiginit, METH_VARARGS, NULL},
6647          { (char *)"ldb_msg_list_elements", (PyCFunction) _wrap_ldb_msg_list_elements, METH_VARARGS | METH_KEYWORDS, NULL},
6648          { (char *)"Message_dn_set", _wrap_Message_dn_set, METH_VARARGS, NULL},
6649          { (char *)"Message_dn_get", (PyCFunction)_wrap_Message_dn_get, METH_O, NULL},
6650          { (char *)"new_Message", (PyCFunction) _wrap_new_Message, METH_VARARGS | METH_KEYWORDS, NULL},
6651          { (char *)"delete_Message", (PyCFunction)_wrap_delete_Message, METH_O, NULL},
6652          { (char *)"Message_find_element", (PyCFunction) _wrap_Message_find_element, METH_VARARGS | METH_KEYWORDS, NULL},
6653          { (char *)"Message___setitem__", _wrap_Message___setitem__, METH_VARARGS, NULL},
6654          { (char *)"Message___len__", (PyCFunction)_wrap_Message___len__, METH_O, NULL},
6655          { (char *)"Message_keys", (PyCFunction)_wrap_Message_keys, METH_O, NULL},
6656          { (char *)"Message___iter__", (PyCFunction)_wrap_Message___iter__, METH_O, NULL},
6657          { (char *)"Message___delitem__", (PyCFunction) _wrap_Message___delitem__, METH_VARARGS | METH_KEYWORDS, NULL},
6658          { (char *)"Message_swigregister", Message_swigregister, METH_VARARGS, NULL},
6659          { (char *)"Message_swiginit", Message_swiginit, METH_VARARGS, NULL},
6660          { (char *)"ldb_ldif_to_pyobject", (PyCFunction) _wrap_ldb_ldif_to_pyobject, METH_VARARGS | METH_KEYWORDS, NULL},
6661          { (char *)"Ldb_firstmodule_set", _wrap_Ldb_firstmodule_set, METH_VARARGS, NULL},
6662          { (char *)"Ldb_firstmodule_get", (PyCFunction)_wrap_Ldb_firstmodule_get, METH_O, NULL},
6663          { (char *)"new_Ldb", (PyCFunction)_wrap_new_Ldb, METH_NOARGS, NULL},
6664          { (char *)"Ldb_connect", (PyCFunction) _wrap_Ldb_connect, METH_VARARGS | METH_KEYWORDS, (char *)"\n"
6665                 "S.connect(url,flags=0,options=None) -> None\n"
6666                 "Connect to a LDB URL.\n"
6667                 ""},
6668          { (char *)"delete_Ldb", (PyCFunction)_wrap_delete_Ldb, METH_O, NULL},
6669          { (char *)"Ldb_search_ex", (PyCFunction) _wrap_Ldb_search_ex, METH_VARARGS | METH_KEYWORDS, NULL},
6670          { (char *)"Ldb_delete", (PyCFunction) _wrap_Ldb_delete, METH_VARARGS | METH_KEYWORDS, (char *)"\n"
6671                 "S.delete(dn) -> None\n"
6672                 "Remove an entry.\n"
6673                 ""},
6674          { (char *)"Ldb_rename", (PyCFunction) _wrap_Ldb_rename, METH_VARARGS | METH_KEYWORDS, (char *)"\n"
6675                 "S.rename(old_dn, new_dn) -> None\n"
6676                 "Rename an entry.\n"
6677                 ""},
6678          { (char *)"Ldb_parse_control_strings", (PyCFunction) _wrap_Ldb_parse_control_strings, METH_VARARGS | METH_KEYWORDS, NULL},
6679          { (char *)"Ldb_add", (PyCFunction) _wrap_Ldb_add, METH_VARARGS | METH_KEYWORDS, (char *)"\n"
6680                 "S.add(message) -> None\n"
6681                 "Add an entry.\n"
6682                 ""},
6683          { (char *)"Ldb_modify", (PyCFunction) _wrap_Ldb_modify, METH_VARARGS | METH_KEYWORDS, (char *)"\n"
6684                 "S.modify(message) -> None\n"
6685                 "Modify an entry.\n"
6686                 ""},
6687          { (char *)"Ldb_get_config_basedn", (PyCFunction)_wrap_Ldb_get_config_basedn, METH_O, NULL},
6688          { (char *)"Ldb_get_root_basedn", (PyCFunction)_wrap_Ldb_get_root_basedn, METH_O, NULL},
6689          { (char *)"Ldb_get_schema_basedn", (PyCFunction)_wrap_Ldb_get_schema_basedn, METH_O, NULL},
6690          { (char *)"Ldb_get_default_basedn", (PyCFunction)_wrap_Ldb_get_default_basedn, METH_O, NULL},
6691          { (char *)"Ldb_schema_format_value", (PyCFunction) _wrap_Ldb_schema_format_value, METH_VARARGS | METH_KEYWORDS, NULL},
6692          { (char *)"Ldb_errstring", (PyCFunction)_wrap_Ldb_errstring, METH_O, NULL},
6693          { (char *)"Ldb_set_create_perms", (PyCFunction) _wrap_Ldb_set_create_perms, METH_VARARGS | METH_KEYWORDS, (char *)"\n"
6694                 "S.set_create_perms(mode) -> None\n"
6695                 "Set mode to use when creating new LDB files.\n"
6696                 ""},
6697          { (char *)"Ldb_set_modules_dir", (PyCFunction) _wrap_Ldb_set_modules_dir, METH_VARARGS | METH_KEYWORDS, (char *)"\n"
6698                 "S.set_modules_dir(path) -> None\n"
6699                 "Set path LDB should search for modules\n"
6700                 ""},
6701          { (char *)"Ldb_set_debug", (PyCFunction) _wrap_Ldb_set_debug, METH_VARARGS | METH_KEYWORDS, (char *)"\n"
6702                 "S.set_debug(callback) -> None\n"
6703                 "Set callback for LDB debug messages.\n"
6704                 "The callback should accept a debug level and debug text.\n"
6705                 ""},
6706          { (char *)"Ldb_set_opaque", (PyCFunction) _wrap_Ldb_set_opaque, METH_VARARGS | METH_KEYWORDS, (char *)"\n"
6707                 "S.set_opaque(name, value) -> None\n"
6708                 "Set an opaque value on this LDB connection. \n"
6709                 ":note: Passing incorrect values may cause crashes.\n"
6710                 ""},
6711          { (char *)"Ldb_get_opaque", (PyCFunction) _wrap_Ldb_get_opaque, METH_VARARGS | METH_KEYWORDS, (char *)"\n"
6712                 "S.get_opaque(name) -> value\n"
6713                 "Get an opaque value set on this LDB connection. \n"
6714                 ":note: The returned value may not be useful in Python.\n"
6715                 ""},
6716          { (char *)"Ldb_transaction_start", (PyCFunction)_wrap_Ldb_transaction_start, METH_O, (char *)"\n"
6717                 "S.transaction_start() -> None\n"
6718                 "Start a new transaction.\n"
6719                 ""},
6720          { (char *)"Ldb_transaction_commit", (PyCFunction)_wrap_Ldb_transaction_commit, METH_O, (char *)"\n"
6721                 "S.transaction_commit() -> None\n"
6722                 "Commit currently active transaction.\n"
6723                 ""},
6724          { (char *)"Ldb_transaction_cancel", (PyCFunction)_wrap_Ldb_transaction_cancel, METH_O, (char *)"\n"
6725                 "S.transaction_cancel() -> None\n"
6726                 "Cancel currently active transaction.\n"
6727                 ""},
6728          { (char *)"Ldb_schema_attribute_remove", (PyCFunction) _wrap_Ldb_schema_attribute_remove, METH_VARARGS | METH_KEYWORDS, NULL},
6729          { (char *)"Ldb_schema_attribute_add", (PyCFunction) _wrap_Ldb_schema_attribute_add, METH_VARARGS | METH_KEYWORDS, NULL},
6730          { (char *)"Ldb_setup_wellknown_attributes", (PyCFunction)_wrap_Ldb_setup_wellknown_attributes, METH_O, NULL},
6731          { (char *)"Ldb___contains__", (PyCFunction) _wrap_Ldb___contains__, METH_VARARGS | METH_KEYWORDS, NULL},
6732          { (char *)"Ldb_parse_ldif", (PyCFunction) _wrap_Ldb_parse_ldif, METH_VARARGS | METH_KEYWORDS, (char *)"\n"
6733                 "S.parse_ldif(ldif) -> iter(messages)\n"
6734                 "Parse a string formatted using LDIF.\n"
6735                 ""},
6736          { (char *)"Ldb___repr__", (PyCFunction)_wrap_Ldb___repr__, METH_O, NULL},
6737          { (char *)"Ldb_swigregister", Ldb_swigregister, METH_VARARGS, NULL},
6738          { (char *)"Ldb_swiginit", Ldb_swiginit, METH_VARARGS, NULL},
6739          { (char *)"valid_attr_name", (PyCFunction) _wrap_valid_attr_name, METH_VARARGS | METH_KEYWORDS, (char *)"\n"
6740                 "S.valid_attr_name(name) -> bool\n"
6741                 "Check whether the supplied name is a valid attribute name.\n"
6742                 ""},
6743          { (char *)"timestring", (PyCFunction) _wrap_timestring, METH_VARARGS | METH_KEYWORDS, (char *)"\n"
6744                 "S.timestring(int) -> string\n"
6745                 "Generate a LDAP time string from a UNIX timestamp\n"
6746                 ""},
6747          { (char *)"string_to_time", (PyCFunction) _wrap_string_to_time, METH_VARARGS | METH_KEYWORDS, (char *)"\n"
6748                 "S.string_to_time(string) -> int\n"
6749                 "Parse a LDAP time string into a UNIX timestamp.\n"
6750                 ""},
6751          { (char *)"ldb_module_prev_set", _wrap_ldb_module_prev_set, METH_VARARGS, NULL},
6752          { (char *)"ldb_module_prev_get", (PyCFunction)_wrap_ldb_module_prev_get, METH_O, NULL},
6753          { (char *)"ldb_module_next_set", _wrap_ldb_module_next_set, METH_VARARGS, NULL},
6754          { (char *)"ldb_module_next_get", (PyCFunction)_wrap_ldb_module_next_get, METH_O, NULL},
6755          { (char *)"ldb_module___str__", (PyCFunction)_wrap_ldb_module___str__, METH_O, NULL},
6756          { (char *)"ldb_module___repr__", (PyCFunction)_wrap_ldb_module___repr__, METH_O, NULL},
6757          { (char *)"ldb_module_search", (PyCFunction) _wrap_ldb_module_search, METH_VARARGS | METH_KEYWORDS, NULL},
6758          { (char *)"ldb_module_add", (PyCFunction) _wrap_ldb_module_add, METH_VARARGS | METH_KEYWORDS, NULL},
6759          { (char *)"ldb_module_modify", (PyCFunction) _wrap_ldb_module_modify, METH_VARARGS | METH_KEYWORDS, NULL},
6760          { (char *)"ldb_module_delete", (PyCFunction) _wrap_ldb_module_delete, METH_VARARGS | METH_KEYWORDS, NULL},
6761          { (char *)"ldb_module_rename", (PyCFunction) _wrap_ldb_module_rename, METH_VARARGS | METH_KEYWORDS, NULL},
6762          { (char *)"ldb_module_start_transaction", (PyCFunction)_wrap_ldb_module_start_transaction, METH_O, NULL},
6763          { (char *)"ldb_module_end_transaction", (PyCFunction)_wrap_ldb_module_end_transaction, METH_O, NULL},
6764          { (char *)"ldb_module_del_transaction", (PyCFunction)_wrap_ldb_module_del_transaction, METH_O, NULL},
6765          { (char *)"new_ldb_module", (PyCFunction)_wrap_new_ldb_module, METH_NOARGS, NULL},
6766          { (char *)"delete_ldb_module", (PyCFunction)_wrap_delete_ldb_module, METH_O, NULL},
6767          { (char *)"ldb_module_swigregister", ldb_module_swigregister, METH_VARARGS, NULL},
6768          { (char *)"ldb_module_swiginit", ldb_module_swiginit, METH_VARARGS, NULL},
6769          { (char *)"register_module", (PyCFunction) _wrap_register_module, METH_VARARGS | METH_KEYWORDS, (char *)"\n"
6770                 "S.register_module(module) -> None\n"
6771                 "Register a LDB module.\n"
6772                 ""},
6773          { NULL, NULL, 0, NULL }
6774 };
6775
6776
6777 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
6778
6779 static swig_type_info _swigt__p_TALLOC_CTX = {"_p_TALLOC_CTX", "TALLOC_CTX *", 0, 0, (void*)0, 0};
6780 static swig_type_info _swigt__p_char = {"_p_char", "char *", 0, 0, (void*)0, 0};
6781 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};
6782 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};
6783 static swig_type_info _swigt__p_ldb_context = {"_p_ldb_context", "struct ldb_context *|ldb *", 0, 0, (void*)0, 0};
6784 static swig_type_info _swigt__p_ldb_dn = {"_p_ldb_dn", "struct ldb_dn *|ldb_dn *", 0, 0, (void*)0, 0};
6785 static swig_type_info _swigt__p_ldb_ldif = {"_p_ldb_ldif", "struct ldb_ldif *|ldb_ldif *", 0, 0, (void*)0, 0};
6786 static swig_type_info _swigt__p_ldb_message = {"_p_ldb_message", "ldb_msg *|struct ldb_message *", 0, 0, (void*)0, 0};
6787 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};
6788 static swig_type_info _swigt__p_ldb_module = {"_p_ldb_module", "struct ldb_module *|ldb_module *", 0, 0, (void*)0, 0};
6789 static swig_type_info _swigt__p_ldb_module_ops = {"_p_ldb_module_ops", "struct ldb_module_ops *", 0, 0, (void*)0, 0};
6790 static swig_type_info _swigt__p_ldb_parse_tree = {"_p_ldb_parse_tree", "struct ldb_parse_tree *", 0, 0, (void*)0, 0};
6791 static swig_type_info _swigt__p_ldb_request = {"_p_ldb_request", "struct ldb_request *", 0, 0, (void*)0, 0};
6792 static swig_type_info _swigt__p_ldb_result = {"_p_ldb_result", "struct ldb_result *", 0, 0, (void*)0, 0};
6793 static swig_type_info _swigt__p_ldb_val = {"_p_ldb_val", "struct ldb_val *", 0, 0, (void*)0, 0};
6794 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};
6795 static swig_type_info _swigt__p_p_char = {"_p_p_char", "char **", 0, 0, (void*)0, 0};
6796 static swig_type_info _swigt__p_p_ldb_control = {"_p_p_ldb_control", "struct ldb_control **", 0, 0, (void*)0, 0};
6797 static swig_type_info _swigt__p_p_ldb_result = {"_p_p_ldb_result", "struct ldb_result **", 0, 0, (void*)0, 0};
6798 static swig_type_info _swigt__p_short = {"_p_short", "short *|int_least16_t *|int16_t *", 0, 0, (void*)0, 0};
6799 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};
6800 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};
6801 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};
6802 static swig_type_info _swigt__p_unsigned_long = {"_p_unsigned_long", "unsigned long *|time_t *", 0, 0, (void*)0, 0};
6803 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};
6804 static swig_type_info _swigt__p_unsigned_short = {"_p_unsigned_short", "unsigned short *|uint_least16_t *|uint16_t *", 0, 0, (void*)0, 0};
6805 static swig_type_info _swigt__p_void = {"_p_void", "void *", 0, 0, (void*)0, 0};
6806
6807 static swig_type_info *swig_type_initial[] = {
6808   &_swigt__p_TALLOC_CTX,
6809   &_swigt__p_char,
6810   &_swigt__p_f_p_void_enum_ldb_debug_level_p_q_const__char_va_list__void,
6811   &_swigt__p_int,
6812   &_swigt__p_ldb_context,
6813   &_swigt__p_ldb_dn,
6814   &_swigt__p_ldb_ldif,
6815   &_swigt__p_ldb_message,
6816   &_swigt__p_ldb_message_element,
6817   &_swigt__p_ldb_module,
6818   &_swigt__p_ldb_module_ops,
6819   &_swigt__p_ldb_parse_tree,
6820   &_swigt__p_ldb_request,
6821   &_swigt__p_ldb_result,
6822   &_swigt__p_ldb_val,
6823   &_swigt__p_long_long,
6824   &_swigt__p_p_char,
6825   &_swigt__p_p_ldb_control,
6826   &_swigt__p_p_ldb_result,
6827   &_swigt__p_short,
6828   &_swigt__p_signed_char,
6829   &_swigt__p_unsigned_char,
6830   &_swigt__p_unsigned_int,
6831   &_swigt__p_unsigned_long,
6832   &_swigt__p_unsigned_long_long,
6833   &_swigt__p_unsigned_short,
6834   &_swigt__p_void,
6835 };
6836
6837 static swig_cast_info _swigc__p_TALLOC_CTX[] = {  {&_swigt__p_TALLOC_CTX, 0, 0, 0},{0, 0, 0, 0}};
6838 static swig_cast_info _swigc__p_char[] = {  {&_swigt__p_char, 0, 0, 0},{0, 0, 0, 0}};
6839 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}};
6840 static swig_cast_info _swigc__p_int[] = {  {&_swigt__p_int, 0, 0, 0},{0, 0, 0, 0}};
6841 static swig_cast_info _swigc__p_ldb_context[] = {  {&_swigt__p_ldb_context, 0, 0, 0},{0, 0, 0, 0}};
6842 static swig_cast_info _swigc__p_ldb_dn[] = {  {&_swigt__p_ldb_dn, 0, 0, 0},{0, 0, 0, 0}};
6843 static swig_cast_info _swigc__p_ldb_ldif[] = {  {&_swigt__p_ldb_ldif, 0, 0, 0},{0, 0, 0, 0}};
6844 static swig_cast_info _swigc__p_ldb_message[] = {  {&_swigt__p_ldb_message, 0, 0, 0},{0, 0, 0, 0}};
6845 static swig_cast_info _swigc__p_ldb_message_element[] = {  {&_swigt__p_ldb_message_element, 0, 0, 0},{0, 0, 0, 0}};
6846 static swig_cast_info _swigc__p_ldb_module[] = {  {&_swigt__p_ldb_module, 0, 0, 0},{0, 0, 0, 0}};
6847 static swig_cast_info _swigc__p_ldb_module_ops[] = {  {&_swigt__p_ldb_module_ops, 0, 0, 0},{0, 0, 0, 0}};
6848 static swig_cast_info _swigc__p_ldb_parse_tree[] = {  {&_swigt__p_ldb_parse_tree, 0, 0, 0},{0, 0, 0, 0}};
6849 static swig_cast_info _swigc__p_ldb_request[] = {  {&_swigt__p_ldb_request, 0, 0, 0},{0, 0, 0, 0}};
6850 static swig_cast_info _swigc__p_ldb_result[] = {  {&_swigt__p_ldb_result, 0, 0, 0},{0, 0, 0, 0}};
6851 static swig_cast_info _swigc__p_ldb_val[] = {  {&_swigt__p_ldb_val, 0, 0, 0},{0, 0, 0, 0}};
6852 static swig_cast_info _swigc__p_long_long[] = {  {&_swigt__p_long_long, 0, 0, 0},{0, 0, 0, 0}};
6853 static swig_cast_info _swigc__p_p_char[] = {  {&_swigt__p_p_char, 0, 0, 0},{0, 0, 0, 0}};
6854 static swig_cast_info _swigc__p_p_ldb_control[] = {  {&_swigt__p_p_ldb_control, 0, 0, 0},{0, 0, 0, 0}};
6855 static swig_cast_info _swigc__p_p_ldb_result[] = {  {&_swigt__p_p_ldb_result, 0, 0, 0},{0, 0, 0, 0}};
6856 static swig_cast_info _swigc__p_short[] = {  {&_swigt__p_short, 0, 0, 0},{0, 0, 0, 0}};
6857 static swig_cast_info _swigc__p_signed_char[] = {  {&_swigt__p_signed_char, 0, 0, 0},{0, 0, 0, 0}};
6858 static swig_cast_info _swigc__p_unsigned_char[] = {  {&_swigt__p_unsigned_char, 0, 0, 0},{0, 0, 0, 0}};
6859 static swig_cast_info _swigc__p_unsigned_int[] = {  {&_swigt__p_unsigned_int, 0, 0, 0},{0, 0, 0, 0}};
6860 static swig_cast_info _swigc__p_unsigned_long[] = {  {&_swigt__p_unsigned_long, 0, 0, 0},{0, 0, 0, 0}};
6861 static swig_cast_info _swigc__p_unsigned_long_long[] = {  {&_swigt__p_unsigned_long_long, 0, 0, 0},{0, 0, 0, 0}};
6862 static swig_cast_info _swigc__p_unsigned_short[] = {  {&_swigt__p_unsigned_short, 0, 0, 0},{0, 0, 0, 0}};
6863 static swig_cast_info _swigc__p_void[] = {  {&_swigt__p_void, 0, 0, 0},{0, 0, 0, 0}};
6864
6865 static swig_cast_info *swig_cast_initial[] = {
6866   _swigc__p_TALLOC_CTX,
6867   _swigc__p_char,
6868   _swigc__p_f_p_void_enum_ldb_debug_level_p_q_const__char_va_list__void,
6869   _swigc__p_int,
6870   _swigc__p_ldb_context,
6871   _swigc__p_ldb_dn,
6872   _swigc__p_ldb_ldif,
6873   _swigc__p_ldb_message,
6874   _swigc__p_ldb_message_element,
6875   _swigc__p_ldb_module,
6876   _swigc__p_ldb_module_ops,
6877   _swigc__p_ldb_parse_tree,
6878   _swigc__p_ldb_request,
6879   _swigc__p_ldb_result,
6880   _swigc__p_ldb_val,
6881   _swigc__p_long_long,
6882   _swigc__p_p_char,
6883   _swigc__p_p_ldb_control,
6884   _swigc__p_p_ldb_result,
6885   _swigc__p_short,
6886   _swigc__p_signed_char,
6887   _swigc__p_unsigned_char,
6888   _swigc__p_unsigned_int,
6889   _swigc__p_unsigned_long,
6890   _swigc__p_unsigned_long_long,
6891   _swigc__p_unsigned_short,
6892   _swigc__p_void,
6893 };
6894
6895
6896 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */
6897
6898 static swig_const_info swig_const_table[] = {
6899 {0, 0, 0, 0.0, 0, 0}};
6900
6901 #ifdef __cplusplus
6902 }
6903 #endif
6904 /* -----------------------------------------------------------------------------
6905  * Type initialization:
6906  * This problem is tough by the requirement that no dynamic
6907  * memory is used. Also, since swig_type_info structures store pointers to
6908  * swig_cast_info structures and swig_cast_info structures store pointers back
6909  * to swig_type_info structures, we need some lookup code at initialization.
6910  * The idea is that swig generates all the structures that are needed.
6911  * The runtime then collects these partially filled structures.
6912  * The SWIG_InitializeModule function takes these initial arrays out of
6913  * swig_module, and does all the lookup, filling in the swig_module.types
6914  * array with the correct data and linking the correct swig_cast_info
6915  * structures together.
6916  *
6917  * The generated swig_type_info structures are assigned staticly to an initial
6918  * array. We just loop through that array, and handle each type individually.
6919  * First we lookup if this type has been already loaded, and if so, use the
6920  * loaded structure instead of the generated one. Then we have to fill in the
6921  * cast linked list. The cast data is initially stored in something like a
6922  * two-dimensional array. Each row corresponds to a type (there are the same
6923  * number of rows as there are in the swig_type_initial array). Each entry in
6924  * a column is one of the swig_cast_info structures for that type.
6925  * The cast_initial array is actually an array of arrays, because each row has
6926  * a variable number of columns. So to actually build the cast linked list,
6927  * we find the array of casts associated with the type, and loop through it
6928  * adding the casts to the list. The one last trick we need to do is making
6929  * sure the type pointer in the swig_cast_info struct is correct.
6930  *
6931  * First off, we lookup the cast->type name to see if it is already loaded.
6932  * There are three cases to handle:
6933  *  1) If the cast->type has already been loaded AND the type we are adding
6934  *     casting info to has not been loaded (it is in this module), THEN we
6935  *     replace the cast->type pointer with the type pointer that has already
6936  *     been loaded.
6937  *  2) If BOTH types (the one we are adding casting info to, and the
6938  *     cast->type) are loaded, THEN the cast info has already been loaded by
6939  *     the previous module so we just ignore it.
6940  *  3) Finally, if cast->type has not already been loaded, then we add that
6941  *     swig_cast_info to the linked list (because the cast->type) pointer will
6942  *     be correct.
6943  * ----------------------------------------------------------------------------- */
6944
6945 #ifdef __cplusplus
6946 extern "C" {
6947 #if 0
6948 } /* c-mode */
6949 #endif
6950 #endif
6951
6952 #if 0
6953 #define SWIGRUNTIME_DEBUG
6954 #endif
6955
6956
6957 SWIGRUNTIME void
6958 SWIG_InitializeModule(void *clientdata) {
6959   size_t i;
6960   swig_module_info *module_head, *iter;
6961   int found, init;
6962
6963   clientdata = clientdata;
6964
6965   /* check to see if the circular list has been setup, if not, set it up */
6966   if (swig_module.next==0) {
6967     /* Initialize the swig_module */
6968     swig_module.type_initial = swig_type_initial;
6969     swig_module.cast_initial = swig_cast_initial;
6970     swig_module.next = &swig_module;
6971     init = 1;
6972   } else {
6973     init = 0;
6974   }
6975
6976   /* Try and load any already created modules */
6977   module_head = SWIG_GetModule(clientdata);
6978   if (!module_head) {
6979     /* This is the first module loaded for this interpreter */
6980     /* so set the swig module into the interpreter */
6981     SWIG_SetModule(clientdata, &swig_module);
6982     module_head = &swig_module;
6983   } else {
6984     /* the interpreter has loaded a SWIG module, but has it loaded this one? */
6985     found=0;
6986     iter=module_head;
6987     do {
6988       if (iter==&swig_module) {
6989         found=1;
6990         break;
6991       }
6992       iter=iter->next;
6993     } while (iter!= module_head);
6994
6995     /* if the is found in the list, then all is done and we may leave */
6996     if (found) return;
6997     /* otherwise we must add out module into the list */
6998     swig_module.next = module_head->next;
6999     module_head->next = &swig_module;
7000   }
7001
7002   /* When multiple interpeters are used, a module could have already been initialized in
7003        a different interpreter, but not yet have a pointer in this interpreter.
7004        In this case, we do not want to continue adding types... everything should be
7005        set up already */
7006   if (init == 0) return;
7007
7008   /* Now work on filling in swig_module.types */
7009 #ifdef SWIGRUNTIME_DEBUG
7010   printf("SWIG_InitializeModule: size %d\n", swig_module.size);
7011 #endif
7012   for (i = 0; i < swig_module.size; ++i) {
7013     swig_type_info *type = 0;
7014     swig_type_info *ret;
7015     swig_cast_info *cast;
7016
7017 #ifdef SWIGRUNTIME_DEBUG
7018     printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
7019 #endif
7020
7021     /* if there is another module already loaded */
7022     if (swig_module.next != &swig_module) {
7023       type = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, swig_module.type_initial[i]->name);
7024     }
7025     if (type) {
7026       /* Overwrite clientdata field */
7027 #ifdef SWIGRUNTIME_DEBUG
7028       printf("SWIG_InitializeModule: found type %s\n", type->name);
7029 #endif
7030       if (swig_module.type_initial[i]->clientdata) {
7031         type->clientdata = swig_module.type_initial[i]->clientdata;
7032 #ifdef SWIGRUNTIME_DEBUG
7033         printf("SWIG_InitializeModule: found and overwrite type %s \n", type->name);
7034 #endif
7035       }
7036     } else {
7037       type = swig_module.type_initial[i];
7038     }
7039
7040     /* Insert casting types */
7041     cast = swig_module.cast_initial[i];
7042     while (cast->type) {
7043       /* Don't need to add information already in the list */
7044       ret = 0;
7045 #ifdef SWIGRUNTIME_DEBUG
7046       printf("SWIG_InitializeModule: look cast %s\n", cast->type->name);
7047 #endif
7048       if (swig_module.next != &swig_module) {
7049         ret = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, cast->type->name);
7050 #ifdef SWIGRUNTIME_DEBUG
7051         if (ret) printf("SWIG_InitializeModule: found cast %s\n", ret->name);
7052 #endif
7053       }
7054       if (ret) {
7055         if (type == swig_module.type_initial[i]) {
7056 #ifdef SWIGRUNTIME_DEBUG
7057           printf("SWIG_InitializeModule: skip old type %s\n", ret->name);
7058 #endif
7059           cast->type = ret;
7060           ret = 0;
7061         } else {
7062           /* Check for casting already in the list */
7063           swig_cast_info *ocast = SWIG_TypeCheck(ret->name, type);
7064 #ifdef SWIGRUNTIME_DEBUG
7065           if (ocast) printf("SWIG_InitializeModule: skip old cast %s\n", ret->name);
7066 #endif
7067           if (!ocast) ret = 0;
7068         }
7069       }
7070
7071       if (!ret) {
7072 #ifdef SWIGRUNTIME_DEBUG
7073         printf("SWIG_InitializeModule: adding cast %s\n", cast->type->name);
7074 #endif
7075         if (type->cast) {
7076           type->cast->prev = cast;
7077           cast->next = type->cast;
7078         }
7079         type->cast = cast;
7080       }
7081       cast++;
7082     }
7083     /* Set entry in modules->types array equal to the type */
7084     swig_module.types[i] = type;
7085   }
7086   swig_module.types[i] = 0;
7087
7088 #ifdef SWIGRUNTIME_DEBUG
7089   printf("**** SWIG_InitializeModule: Cast List ******\n");
7090   for (i = 0; i < swig_module.size; ++i) {
7091     int j = 0;
7092     swig_cast_info *cast = swig_module.cast_initial[i];
7093     printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
7094     while (cast->type) {
7095       printf("SWIG_InitializeModule: cast type %s\n", cast->type->name);
7096       cast++;
7097       ++j;
7098     }
7099     printf("---- Total casts: %d\n",j);
7100   }
7101   printf("**** SWIG_InitializeModule: Cast List ******\n");
7102 #endif
7103 }
7104
7105 /* This function will propagate the clientdata field of type to
7106 * any new swig_type_info structures that have been added into the list
7107 * of equivalent types.  It is like calling
7108 * SWIG_TypeClientData(type, clientdata) a second time.
7109 */
7110 SWIGRUNTIME void
7111 SWIG_PropagateClientData(void) {
7112   size_t i;
7113   swig_cast_info *equiv;
7114   static int init_run = 0;
7115
7116   if (init_run) return;
7117   init_run = 1;
7118
7119   for (i = 0; i < swig_module.size; i++) {
7120     if (swig_module.types[i]->clientdata) {
7121       equiv = swig_module.types[i]->cast;
7122       while (equiv) {
7123         if (!equiv->converter) {
7124           if (equiv->type && !equiv->type->clientdata)
7125           SWIG_TypeClientData(equiv->type, swig_module.types[i]->clientdata);
7126         }
7127         equiv = equiv->next;
7128       }
7129     }
7130   }
7131 }
7132
7133 #ifdef __cplusplus
7134 #if 0
7135 {
7136   /* c-mode */
7137 #endif
7138 }
7139 #endif
7140
7141
7142
7143 #ifdef __cplusplus
7144 extern "C" {
7145 #endif
7146
7147   /* Python-specific SWIG API */
7148 #define SWIG_newvarlink()                             SWIG_Python_newvarlink()
7149 #define SWIG_addvarlink(p, name, get_attr, set_attr)  SWIG_Python_addvarlink(p, name, get_attr, set_attr)
7150 #define SWIG_InstallConstants(d, constants)           SWIG_Python_InstallConstants(d, constants)
7151
7152   /* -----------------------------------------------------------------------------
7153    * global variable support code.
7154    * ----------------------------------------------------------------------------- */
7155
7156   typedef struct swig_globalvar {
7157     char       *name;                  /* Name of global variable */
7158     PyObject *(*get_attr)(void);       /* Return the current value */
7159     int       (*set_attr)(PyObject *); /* Set the value */
7160     struct swig_globalvar *next;
7161   } swig_globalvar;
7162
7163   typedef struct swig_varlinkobject {
7164     PyObject_HEAD
7165     swig_globalvar *vars;
7166   } swig_varlinkobject;
7167
7168   SWIGINTERN PyObject *
7169   swig_varlink_repr(swig_varlinkobject *SWIGUNUSEDPARM(v)) {
7170     return PyString_FromString("<Swig global variables>");
7171   }
7172
7173   SWIGINTERN PyObject *
7174   swig_varlink_str(swig_varlinkobject *v) {
7175     PyObject *str = PyString_FromString("(");
7176     swig_globalvar  *var;
7177     for (var = v->vars; var; var=var->next) {
7178       PyString_ConcatAndDel(&str,PyString_FromString(var->name));
7179       if (var->next) PyString_ConcatAndDel(&str,PyString_FromString(", "));
7180     }
7181     PyString_ConcatAndDel(&str,PyString_FromString(")"));
7182     return str;
7183   }
7184
7185   SWIGINTERN int
7186   swig_varlink_print(swig_varlinkobject *v, FILE *fp, int SWIGUNUSEDPARM(flags)) {
7187     PyObject *str = swig_varlink_str(v);
7188     fprintf(fp,"Swig global variables ");
7189     fprintf(fp,"%s\n", PyString_AsString(str));
7190     Py_DECREF(str);
7191     return 0;
7192   }
7193
7194   SWIGINTERN void
7195   swig_varlink_dealloc(swig_varlinkobject *v) {
7196     swig_globalvar *var = v->vars;
7197     while (var) {
7198       swig_globalvar *n = var->next;
7199       free(var->name);
7200       free(var);
7201       var = n;
7202     }
7203   }
7204
7205   SWIGINTERN PyObject *
7206   swig_varlink_getattr(swig_varlinkobject *v, char *n) {
7207     PyObject *res = NULL;
7208     swig_globalvar *var = v->vars;
7209     while (var) {
7210       if (strcmp(var->name,n) == 0) {
7211         res = (*var->get_attr)();
7212         break;
7213       }
7214       var = var->next;
7215     }
7216     if (res == NULL && !PyErr_Occurred()) {
7217       PyErr_SetString(PyExc_NameError,"Unknown C global variable");
7218     }
7219     return res;
7220   }
7221
7222   SWIGINTERN int
7223   swig_varlink_setattr(swig_varlinkobject *v, char *n, PyObject *p) {
7224     int res = 1;
7225     swig_globalvar *var = v->vars;
7226     while (var) {
7227       if (strcmp(var->name,n) == 0) {
7228         res = (*var->set_attr)(p);
7229         break;
7230       }
7231       var = var->next;
7232     }
7233     if (res == 1 && !PyErr_Occurred()) {
7234       PyErr_SetString(PyExc_NameError,"Unknown C global variable");
7235     }
7236     return res;
7237   }
7238
7239   SWIGINTERN PyTypeObject*
7240   swig_varlink_type(void) {
7241     static char varlink__doc__[] = "Swig var link object";
7242     static PyTypeObject varlink_type;
7243     static int type_init = 0;
7244     if (!type_init) {
7245       const PyTypeObject tmp
7246       = {
7247         PyObject_HEAD_INIT(NULL)
7248         0,                                  /* Number of items in variable part (ob_size) */
7249         (char *)"swigvarlink",              /* Type name (tp_name) */
7250         sizeof(swig_varlinkobject),         /* Basic size (tp_basicsize) */
7251         0,                                  /* Itemsize (tp_itemsize) */
7252         (destructor) swig_varlink_dealloc,   /* Deallocator (tp_dealloc) */
7253         (printfunc) swig_varlink_print,     /* Print (tp_print) */
7254         (getattrfunc) swig_varlink_getattr, /* get attr (tp_getattr) */
7255         (setattrfunc) swig_varlink_setattr, /* Set attr (tp_setattr) */
7256         0,                                  /* tp_compare */
7257         (reprfunc) swig_varlink_repr,       /* tp_repr */
7258         0,                                  /* tp_as_number */
7259         0,                                  /* tp_as_sequence */
7260         0,                                  /* tp_as_mapping */
7261         0,                                  /* tp_hash */
7262         0,                                  /* tp_call */
7263         (reprfunc)swig_varlink_str,        /* tp_str */
7264         0,                                  /* tp_getattro */
7265         0,                                  /* tp_setattro */
7266         0,                                  /* tp_as_buffer */
7267         0,                                  /* tp_flags */
7268         varlink__doc__,                     /* tp_doc */
7269         0,                                  /* tp_traverse */
7270         0,                                  /* tp_clear */
7271         0,                                  /* tp_richcompare */
7272         0,                                  /* tp_weaklistoffset */
7273 #if PY_VERSION_HEX >= 0x02020000
7274         0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
7275 #endif
7276 #if PY_VERSION_HEX >= 0x02030000
7277         0,                                  /* tp_del */
7278 #endif
7279 #ifdef COUNT_ALLOCS
7280         0,0,0,0                             /* tp_alloc -> tp_next */
7281 #endif
7282       };
7283       varlink_type = tmp;
7284       varlink_type.ob_type = &PyType_Type;
7285       type_init = 1;
7286     }
7287     return &varlink_type;
7288   }
7289
7290   /* Create a variable linking object for use later */
7291   SWIGINTERN PyObject *
7292   SWIG_Python_newvarlink(void) {
7293     swig_varlinkobject *result = PyObject_NEW(swig_varlinkobject, swig_varlink_type());
7294     if (result) {
7295       result->vars = 0;
7296     }
7297     return ((PyObject*) result);
7298   }
7299
7300   SWIGINTERN void
7301   SWIG_Python_addvarlink(PyObject *p, char *name, PyObject *(*get_attr)(void), int (*set_attr)(PyObject *p)) {
7302     swig_varlinkobject *v = (swig_varlinkobject *) p;
7303     swig_globalvar *gv = (swig_globalvar *) malloc(sizeof(swig_globalvar));
7304     if (gv) {
7305       size_t size = strlen(name)+1;
7306       gv->name = (char *)malloc(size);
7307       if (gv->name) {
7308         strncpy(gv->name,name,size);
7309         gv->get_attr = get_attr;
7310         gv->set_attr = set_attr;
7311         gv->next = v->vars;
7312       }
7313     }
7314     v->vars = gv;
7315   }
7316
7317   SWIGINTERN PyObject *
7318   SWIG_globals(void) {
7319     static PyObject *_SWIG_globals = 0;
7320     if (!_SWIG_globals) _SWIG_globals = SWIG_newvarlink();
7321     return _SWIG_globals;
7322   }
7323
7324   /* -----------------------------------------------------------------------------
7325    * constants/methods manipulation
7326    * ----------------------------------------------------------------------------- */
7327
7328   /* Install Constants */
7329   SWIGINTERN void
7330   SWIG_Python_InstallConstants(PyObject *d, swig_const_info constants[]) {
7331     PyObject *obj = 0;
7332     size_t i;
7333     for (i = 0; constants[i].type; ++i) {
7334       switch(constants[i].type) {
7335       case SWIG_PY_POINTER:
7336         obj = SWIG_NewPointerObj(constants[i].pvalue, *(constants[i]).ptype,0);
7337         break;
7338       case SWIG_PY_BINARY:
7339         obj = SWIG_NewPackedObj(constants[i].pvalue, constants[i].lvalue, *(constants[i].ptype));
7340         break;
7341       default:
7342         obj = 0;
7343         break;
7344       }
7345       if (obj) {
7346         PyDict_SetItemString(d, constants[i].name, obj);
7347         Py_DECREF(obj);
7348       }
7349     }
7350   }
7351
7352   /* -----------------------------------------------------------------------------*/
7353   /* Fix SwigMethods to carry the callback ptrs when needed */
7354   /* -----------------------------------------------------------------------------*/
7355
7356   SWIGINTERN void
7357   SWIG_Python_FixMethods(PyMethodDef *methods,
7358     swig_const_info *const_table,
7359     swig_type_info **types,
7360     swig_type_info **types_initial) {
7361     size_t i;
7362     for (i = 0; methods[i].ml_name; ++i) {
7363       const char *c = methods[i].ml_doc;
7364       if (c && (c = strstr(c, "swig_ptr: "))) {
7365         int j;
7366         swig_const_info *ci = 0;
7367         const char *name = c + 10;
7368         for (j = 0; const_table[j].type; ++j) {
7369           if (strncmp(const_table[j].name, name,
7370               strlen(const_table[j].name)) == 0) {
7371             ci = &(const_table[j]);
7372             break;
7373           }
7374         }
7375         if (ci) {
7376           size_t shift = (ci->ptype) - types;
7377           swig_type_info *ty = types_initial[shift];
7378           size_t ldoc = (c - methods[i].ml_doc);
7379           size_t lptr = strlen(ty->name)+2*sizeof(void*)+2;
7380           char *ndoc = (char*)malloc(ldoc + lptr + 10);
7381           if (ndoc) {
7382             char *buff = ndoc;
7383             void *ptr = (ci->type == SWIG_PY_POINTER) ? ci->pvalue : 0;
7384             if (ptr) {
7385               strncpy(buff, methods[i].ml_doc, ldoc);
7386               buff += ldoc;
7387               strncpy(buff, "swig_ptr: ", 10);
7388               buff += 10;
7389               SWIG_PackVoidPtr(buff, ptr, ty->name, lptr);
7390               methods[i].ml_doc = ndoc;
7391             }
7392           }
7393         }
7394       }
7395     }
7396   }
7397
7398 #ifdef __cplusplus
7399 }
7400 #endif
7401
7402 /* -----------------------------------------------------------------------------*
7403  *  Partial Init method
7404  * -----------------------------------------------------------------------------*/
7405
7406 #ifdef __cplusplus
7407 extern "C"
7408 #endif
7409 SWIGEXPORT void SWIG_init(void) {
7410   PyObject *m, *d;
7411
7412   /* Fix SwigMethods to carry the callback ptrs when needed */
7413   SWIG_Python_FixMethods(SwigMethods, swig_const_table, swig_types, swig_type_initial);
7414
7415   m = Py_InitModule((char *) SWIG_name, SwigMethods);
7416   d = PyModule_GetDict(m);
7417
7418   SWIG_InitializeModule(0);
7419   SWIG_InstallConstants(d,swig_const_table);
7420
7421
7422   SWIG_Python_SetConstant(d, "SCOPE_DEFAULT",SWIG_From_int((int)(LDB_SCOPE_DEFAULT)));
7423   SWIG_Python_SetConstant(d, "SCOPE_BASE",SWIG_From_int((int)(LDB_SCOPE_BASE)));
7424   SWIG_Python_SetConstant(d, "SCOPE_ONELEVEL",SWIG_From_int((int)(LDB_SCOPE_ONELEVEL)));
7425   SWIG_Python_SetConstant(d, "SCOPE_SUBTREE",SWIG_From_int((int)(LDB_SCOPE_SUBTREE)));
7426   SWIG_Python_SetConstant(d, "CHANGETYPE_NONE",SWIG_From_int((int)(LDB_CHANGETYPE_NONE)));
7427   SWIG_Python_SetConstant(d, "CHANGETYPE_ADD",SWIG_From_int((int)(LDB_CHANGETYPE_ADD)));
7428   SWIG_Python_SetConstant(d, "CHANGETYPE_DELETE",SWIG_From_int((int)(LDB_CHANGETYPE_DELETE)));
7429   SWIG_Python_SetConstant(d, "CHANGETYPE_MODIFY",SWIG_From_int((int)(LDB_CHANGETYPE_MODIFY)));
7430
7431   PyExc_LdbError = PyErr_NewException((char *)"_ldb.LdbError", NULL, NULL);
7432   PyDict_SetItemString(d, "LdbError", PyExc_LdbError);
7433
7434   SWIG_Python_SetConstant(d, "LDB_ERR_OPERATIONS_ERROR",SWIG_From_int((int)(1)));
7435   SWIG_Python_SetConstant(d, "LDB_ERR_PROTOCOL_ERROR",SWIG_From_int((int)(2)));
7436   SWIG_Python_SetConstant(d, "LDB_ERR_TIME_LIMIT_EXCEEDED",SWIG_From_int((int)(3)));
7437   SWIG_Python_SetConstant(d, "LDB_ERR_SIZE_LIMIT_EXCEEDED",SWIG_From_int((int)(4)));
7438   SWIG_Python_SetConstant(d, "LDB_ERR_COMPARE_FALSE",SWIG_From_int((int)(5)));
7439   SWIG_Python_SetConstant(d, "LDB_ERR_COMPARE_TRUE",SWIG_From_int((int)(6)));
7440   SWIG_Python_SetConstant(d, "LDB_ERR_AUTH_METHOD_NOT_SUPPORTED",SWIG_From_int((int)(7)));
7441   SWIG_Python_SetConstant(d, "LDB_ERR_STRONG_AUTH_REQUIRED",SWIG_From_int((int)(8)));
7442   SWIG_Python_SetConstant(d, "LDB_ERR_REFERRAL",SWIG_From_int((int)(10)));
7443   SWIG_Python_SetConstant(d, "LDB_ERR_ADMIN_LIMIT_EXCEEDED",SWIG_From_int((int)(11)));
7444   SWIG_Python_SetConstant(d, "LDB_ERR_UNSUPPORTED_CRITICAL_EXTENSION",SWIG_From_int((int)(12)));
7445   SWIG_Python_SetConstant(d, "LDB_ERR_CONFIDENTIALITY_REQUIRED",SWIG_From_int((int)(13)));
7446   SWIG_Python_SetConstant(d, "LDB_ERR_SASL_BIND_IN_PROGRESS",SWIG_From_int((int)(14)));
7447   SWIG_Python_SetConstant(d, "LDB_ERR_NO_SUCH_ATTRIBUTE",SWIG_From_int((int)(16)));
7448   SWIG_Python_SetConstant(d, "LDB_ERR_UNDEFINED_ATTRIBUTE_TYPE",SWIG_From_int((int)(17)));
7449   SWIG_Python_SetConstant(d, "LDB_ERR_INAPPROPRIATE_MATCHING",SWIG_From_int((int)(18)));
7450   SWIG_Python_SetConstant(d, "LDB_ERR_CONSTRAINT_VIOLATION",SWIG_From_int((int)(19)));
7451   SWIG_Python_SetConstant(d, "LDB_ERR_ATTRIBUTE_OR_VALUE_EXISTS",SWIG_From_int((int)(20)));
7452   SWIG_Python_SetConstant(d, "LDB_ERR_INVALID_ATTRIBUTE_SYNTAX",SWIG_From_int((int)(21)));
7453   SWIG_Python_SetConstant(d, "LDB_ERR_NO_SUCH_OBJECT",SWIG_From_int((int)(32)));
7454   SWIG_Python_SetConstant(d, "LDB_ERR_ALIAS_PROBLEM",SWIG_From_int((int)(33)));
7455   SWIG_Python_SetConstant(d, "LDB_ERR_INVALID_DN_SYNTAX",SWIG_From_int((int)(34)));
7456   SWIG_Python_SetConstant(d, "LDB_ERR_ALIAS_DEREFERENCING_PROBLEM",SWIG_From_int((int)(36)));
7457   SWIG_Python_SetConstant(d, "LDB_ERR_INAPPROPRIATE_AUTHENTICATION",SWIG_From_int((int)(48)));
7458   SWIG_Python_SetConstant(d, "LDB_ERR_INVALID_CREDENTIALS",SWIG_From_int((int)(49)));
7459   SWIG_Python_SetConstant(d, "LDB_ERR_INSUFFICIENT_ACCESS_RIGHTS",SWIG_From_int((int)(50)));
7460   SWIG_Python_SetConstant(d, "LDB_ERR_BUSY",SWIG_From_int((int)(51)));
7461   SWIG_Python_SetConstant(d, "LDB_ERR_UNAVAILABLE",SWIG_From_int((int)(52)));
7462   SWIG_Python_SetConstant(d, "LDB_ERR_UNWILLING_TO_PERFORM",SWIG_From_int((int)(53)));
7463   SWIG_Python_SetConstant(d, "LDB_ERR_LOOP_DETECT",SWIG_From_int((int)(54)));
7464   SWIG_Python_SetConstant(d, "LDB_ERR_NAMING_VIOLATION",SWIG_From_int((int)(64)));
7465   SWIG_Python_SetConstant(d, "LDB_ERR_OBJECT_CLASS_VIOLATION",SWIG_From_int((int)(65)));
7466   SWIG_Python_SetConstant(d, "LDB_ERR_NOT_ALLOWED_ON_NON_LEAF",SWIG_From_int((int)(66)));
7467   SWIG_Python_SetConstant(d, "LDB_ERR_NOT_ALLOWED_ON_RDN",SWIG_From_int((int)(67)));
7468   SWIG_Python_SetConstant(d, "LDB_ERR_ENTRY_ALREADY_EXISTS",SWIG_From_int((int)(68)));
7469   SWIG_Python_SetConstant(d, "LDB_ERR_OBJECT_CLASS_MODS_PROHIBITED",SWIG_From_int((int)(69)));
7470   SWIG_Python_SetConstant(d, "LDB_ERR_AFFECTS_MULTIPLE_DSAS",SWIG_From_int((int)(71)));
7471   SWIG_Python_SetConstant(d, "LDB_ERR_OTHER",SWIG_From_int((int)(80)));
7472 }
7473