source4/lib/ldb/ldb_wrap.c

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