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