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