source4/lib/ldb/ldb_wrap.c

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