source4/lib/ldb/ldb_wrap.c

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