source4/lib/ldb/ldb_wrap.c

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