source4/lib/ldb/ldb_wrap.c

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