Index: swig/perl/abac_wrap.cxx
===================================================================
--- swig/perl/abac_wrap.cxx	(revision 80a0f3f2182a90cbb685f63c76497308dc027710)
+++ swig/perl/abac_wrap.cxx	(revision 80a0f3f2182a90cbb685f63c76497308dc027710)
@@ -0,0 +1,11626 @@
+/* ----------------------------------------------------------------------------
+ * This file was automatically generated by SWIG (http://www.swig.org).
+ * Version 3.0.10
+ *
+ * This file is not intended to be easily readable and contains a number of
+ * coding conventions designed to improve portability and efficiency. Do not make
+ * changes to this file unless you know what you are doing--modify the SWIG
+ * interface file instead.
+ * ----------------------------------------------------------------------------- */
+
+
+#ifndef SWIGPERL
+#define SWIGPERL
+#endif
+
+#define SWIG_CASTRANK_MODE
+
+
+#ifdef __cplusplus
+/* SwigValueWrapper is described in swig.swg */
+template<typename T> class SwigValueWrapper {
+  struct SwigMovePointer {
+    T *ptr;
+    SwigMovePointer(T *p) : ptr(p) { }
+    ~SwigMovePointer() { delete ptr; }
+    SwigMovePointer& operator=(SwigMovePointer& rhs) { T* oldptr = ptr; ptr = 0; delete oldptr; ptr = rhs.ptr; rhs.ptr = 0; return *this; }
+  } pointer;
+  SwigValueWrapper& operator=(const SwigValueWrapper<T>& rhs);
+  SwigValueWrapper(const SwigValueWrapper<T>& rhs);
+public:
+  SwigValueWrapper() : pointer(0) { }
+  SwigValueWrapper& operator=(const T& t) { SwigMovePointer tmp(new T(t)); pointer = tmp; return *this; }
+  operator T&() const { return *pointer.ptr; }
+  T *operator&() { return pointer.ptr; }
+};
+
+template <typename T> T SwigValueInit() {
+  return T();
+}
+#endif
+
+/* -----------------------------------------------------------------------------
+ *  This section contains generic SWIG labels for method/variable
+ *  declarations/attributes, and other compiler dependent labels.
+ * ----------------------------------------------------------------------------- */
+
+/* template workaround for compilers that cannot correctly implement the C++ standard */
+#ifndef SWIGTEMPLATEDISAMBIGUATOR
+# if defined(__SUNPRO_CC) && (__SUNPRO_CC <= 0x560)
+#  define SWIGTEMPLATEDISAMBIGUATOR template
+# elif defined(__HP_aCC)
+/* Needed even with `aCC -AA' when `aCC -V' reports HP ANSI C++ B3910B A.03.55 */
+/* If we find a maximum version that requires this, the test would be __HP_aCC <= 35500 for A.03.55 */
+#  define SWIGTEMPLATEDISAMBIGUATOR template
+# else
+#  define SWIGTEMPLATEDISAMBIGUATOR
+# endif
+#endif
+
+/* inline attribute */
+#ifndef SWIGINLINE
+# if defined(__cplusplus) || (defined(__GNUC__) && !defined(__STRICT_ANSI__))
+#   define SWIGINLINE inline
+# else
+#   define SWIGINLINE
+# endif
+#endif
+
+/* attribute recognised by some compilers to avoid 'unused' warnings */
+#ifndef SWIGUNUSED
+# if defined(__GNUC__)
+#   if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4))
+#     define SWIGUNUSED __attribute__ ((__unused__))
+#   else
+#     define SWIGUNUSED
+#   endif
+# elif defined(__ICC)
+#   define SWIGUNUSED __attribute__ ((__unused__))
+# else
+#   define SWIGUNUSED
+# endif
+#endif
+
+#ifndef SWIG_MSC_UNSUPPRESS_4505
+# if defined(_MSC_VER)
+#   pragma warning(disable : 4505) /* unreferenced local function has been removed */
+# endif
+#endif
+
+#ifndef SWIGUNUSEDPARM
+# ifdef __cplusplus
+#   define SWIGUNUSEDPARM(p)
+# else
+#   define SWIGUNUSEDPARM(p) p SWIGUNUSED
+# endif
+#endif
+
+/* internal SWIG method */
+#ifndef SWIGINTERN
+# define SWIGINTERN static SWIGUNUSED
+#endif
+
+/* internal inline SWIG method */
+#ifndef SWIGINTERNINLINE
+# define SWIGINTERNINLINE SWIGINTERN SWIGINLINE
+#endif
+
+/* exporting methods */
+#if defined(__GNUC__)
+#  if (__GNUC__ >= 4) || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)
+#    ifndef GCC_HASCLASSVISIBILITY
+#      define GCC_HASCLASSVISIBILITY
+#    endif
+#  endif
+#endif
+
+#ifndef SWIGEXPORT
+# if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
+#   if defined(STATIC_LINKED)
+#     define SWIGEXPORT
+#   else
+#     define SWIGEXPORT __declspec(dllexport)
+#   endif
+# else
+#   if defined(__GNUC__) && defined(GCC_HASCLASSVISIBILITY)
+#     define SWIGEXPORT __attribute__ ((visibility("default")))
+#   else
+#     define SWIGEXPORT
+#   endif
+# endif
+#endif
+
+/* calling conventions for Windows */
+#ifndef SWIGSTDCALL
+# if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
+#   define SWIGSTDCALL __stdcall
+# else
+#   define SWIGSTDCALL
+# endif
+#endif
+
+/* Deal with Microsoft's attempt at deprecating C standard runtime functions */
+#if !defined(SWIG_NO_CRT_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_CRT_SECURE_NO_DEPRECATE)
+# define _CRT_SECURE_NO_DEPRECATE
+#endif
+
+/* Deal with Microsoft's attempt at deprecating methods in the standard C++ library */
+#if !defined(SWIG_NO_SCL_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_SCL_SECURE_NO_DEPRECATE)
+# define _SCL_SECURE_NO_DEPRECATE
+#endif
+
+/* Deal with Apple's deprecated 'AssertMacros.h' from Carbon-framework */
+#if defined(__APPLE__) && !defined(__ASSERT_MACROS_DEFINE_VERSIONS_WITHOUT_UNDERSCORES)
+# define __ASSERT_MACROS_DEFINE_VERSIONS_WITHOUT_UNDERSCORES 0
+#endif
+
+/* Intel's compiler complains if a variable which was never initialised is
+ * cast to void, which is a common idiom which we use to indicate that we
+ * are aware a variable isn't used.  So we just silence that warning.
+ * See: https://github.com/swig/swig/issues/192 for more discussion.
+ */
+#ifdef __INTEL_COMPILER
+# pragma warning disable 592
+#endif
+
+/* -----------------------------------------------------------------------------
+ * swigrun.swg
+ *
+ * This file contains generic C API SWIG runtime support for pointer
+ * type checking.
+ * ----------------------------------------------------------------------------- */
+
+/* This should only be incremented when either the layout of swig_type_info changes,
+   or for whatever reason, the runtime changes incompatibly */
+#define SWIG_RUNTIME_VERSION "4"
+
+/* define SWIG_TYPE_TABLE_NAME as "SWIG_TYPE_TABLE" */
+#ifdef SWIG_TYPE_TABLE
+# define SWIG_QUOTE_STRING(x) #x
+# define SWIG_EXPAND_AND_QUOTE_STRING(x) SWIG_QUOTE_STRING(x)
+# define SWIG_TYPE_TABLE_NAME SWIG_EXPAND_AND_QUOTE_STRING(SWIG_TYPE_TABLE)
+#else
+# define SWIG_TYPE_TABLE_NAME
+#endif
+
+/*
+  You can use the SWIGRUNTIME and SWIGRUNTIMEINLINE macros for
+  creating a static or dynamic library from the SWIG runtime code.
+  In 99.9% of the cases, SWIG just needs to declare them as 'static'.
+
+  But only do this if strictly necessary, ie, if you have problems
+  with your compiler or suchlike.
+*/
+
+#ifndef SWIGRUNTIME
+# define SWIGRUNTIME SWIGINTERN
+#endif
+
+#ifndef SWIGRUNTIMEINLINE
+# define SWIGRUNTIMEINLINE SWIGRUNTIME SWIGINLINE
+#endif
+
+/*  Generic buffer size */
+#ifndef SWIG_BUFFER_SIZE
+# define SWIG_BUFFER_SIZE 1024
+#endif
+
+/* Flags for pointer conversions */
+#define SWIG_POINTER_DISOWN        0x1
+#define SWIG_CAST_NEW_MEMORY       0x2
+
+/* Flags for new pointer objects */
+#define SWIG_POINTER_OWN           0x1
+
+
+/*
+   Flags/methods for returning states.
+
+   The SWIG conversion methods, as ConvertPtr, return an integer
+   that tells if the conversion was successful or not. And if not,
+   an error code can be returned (see swigerrors.swg for the codes).
+
+   Use the following macros/flags to set or process the returning
+   states.
+
+   In old versions of SWIG, code such as the following was usually written:
+
+     if (SWIG_ConvertPtr(obj,vptr,ty.flags) != -1) {
+       // success code
+     } else {
+       //fail code
+     }
+
+   Now you can be more explicit:
+
+    int res = SWIG_ConvertPtr(obj,vptr,ty.flags);
+    if (SWIG_IsOK(res)) {
+      // success code
+    } else {
+      // fail code
+    }
+
+   which is the same really, but now you can also do
+
+    Type *ptr;
+    int res = SWIG_ConvertPtr(obj,(void **)(&ptr),ty.flags);
+    if (SWIG_IsOK(res)) {
+      // success code
+      if (SWIG_IsNewObj(res) {
+        ...
+	delete *ptr;
+      } else {
+        ...
+      }
+    } else {
+      // fail code
+    }
+
+   I.e., now SWIG_ConvertPtr can return new objects and you can
+   identify the case and take care of the deallocation. Of course that
+   also requires SWIG_ConvertPtr to return new result values, such as
+
+      int SWIG_ConvertPtr(obj, ptr,...) {
+        if (<obj is ok>) {
+          if (<need new object>) {
+            *ptr = <ptr to new allocated object>;
+            return SWIG_NEWOBJ;
+          } else {
+            *ptr = <ptr to old object>;
+            return SWIG_OLDOBJ;
+          }
+        } else {
+          return SWIG_BADOBJ;
+        }
+      }
+
+   Of course, returning the plain '0(success)/-1(fail)' still works, but you can be
+   more explicit by returning SWIG_BADOBJ, SWIG_ERROR or any of the
+   SWIG errors code.
+
+   Finally, if the SWIG_CASTRANK_MODE is enabled, the result code
+   allows to return the 'cast rank', for example, if you have this
+
+       int food(double)
+       int fooi(int);
+
+   and you call
+
+      food(1)   // cast rank '1'  (1 -> 1.0)
+      fooi(1)   // cast rank '0'
+
+   just use the SWIG_AddCast()/SWIG_CheckState()
+*/
+
+#define SWIG_OK                    (0)
+#define SWIG_ERROR                 (-1)
+#define SWIG_IsOK(r)               (r >= 0)
+#define SWIG_ArgError(r)           ((r != SWIG_ERROR) ? r : SWIG_TypeError)
+
+/* The CastRankLimit says how many bits are used for the cast rank */
+#define SWIG_CASTRANKLIMIT         (1 << 8)
+/* The NewMask denotes the object was created (using new/malloc) */
+#define SWIG_NEWOBJMASK            (SWIG_CASTRANKLIMIT  << 1)
+/* The TmpMask is for in/out typemaps that use temporal objects */
+#define SWIG_TMPOBJMASK            (SWIG_NEWOBJMASK << 1)
+/* Simple returning values */
+#define SWIG_BADOBJ                (SWIG_ERROR)
+#define SWIG_OLDOBJ                (SWIG_OK)
+#define SWIG_NEWOBJ                (SWIG_OK | SWIG_NEWOBJMASK)
+#define SWIG_TMPOBJ                (SWIG_OK | SWIG_TMPOBJMASK)
+/* Check, add and del mask methods */
+#define SWIG_AddNewMask(r)         (SWIG_IsOK(r) ? (r | SWIG_NEWOBJMASK) : r)
+#define SWIG_DelNewMask(r)         (SWIG_IsOK(r) ? (r & ~SWIG_NEWOBJMASK) : r)
+#define SWIG_IsNewObj(r)           (SWIG_IsOK(r) && (r & SWIG_NEWOBJMASK))
+#define SWIG_AddTmpMask(r)         (SWIG_IsOK(r) ? (r | SWIG_TMPOBJMASK) : r)
+#define SWIG_DelTmpMask(r)         (SWIG_IsOK(r) ? (r & ~SWIG_TMPOBJMASK) : r)
+#define SWIG_IsTmpObj(r)           (SWIG_IsOK(r) && (r & SWIG_TMPOBJMASK))
+
+/* Cast-Rank Mode */
+#if defined(SWIG_CASTRANK_MODE)
+#  ifndef SWIG_TypeRank
+#    define SWIG_TypeRank             unsigned long
+#  endif
+#  ifndef SWIG_MAXCASTRANK            /* Default cast allowed */
+#    define SWIG_MAXCASTRANK          (2)
+#  endif
+#  define SWIG_CASTRANKMASK          ((SWIG_CASTRANKLIMIT) -1)
+#  define SWIG_CastRank(r)           (r & SWIG_CASTRANKMASK)
+SWIGINTERNINLINE int SWIG_AddCast(int r) {
+  return SWIG_IsOK(r) ? ((SWIG_CastRank(r) < SWIG_MAXCASTRANK) ? (r + 1) : SWIG_ERROR) : r;
+}
+SWIGINTERNINLINE int SWIG_CheckState(int r) {
+  return SWIG_IsOK(r) ? SWIG_CastRank(r) + 1 : 0;
+}
+#else /* no cast-rank mode */
+#  define SWIG_AddCast(r) (r)
+#  define SWIG_CheckState(r) (SWIG_IsOK(r) ? 1 : 0)
+#endif
+
+
+#include <string.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef void *(*swig_converter_func)(void *, int *);
+typedef struct swig_type_info *(*swig_dycast_func)(void **);
+
+/* Structure to store information on one type */
+typedef struct swig_type_info {
+  const char             *name;			/* mangled name of this type */
+  const char             *str;			/* human readable name of this type */
+  swig_dycast_func        dcast;		/* dynamic cast function down a hierarchy */
+  struct swig_cast_info  *cast;			/* linked list of types that can cast into this type */
+  void                   *clientdata;		/* language specific type data */
+  int                    owndata;		/* flag if the structure owns the clientdata */
+} swig_type_info;
+
+/* Structure to store a type and conversion function used for casting */
+typedef struct swig_cast_info {
+  swig_type_info         *type;			/* pointer to type that is equivalent to this type */
+  swig_converter_func     converter;		/* function to cast the void pointers */
+  struct swig_cast_info  *next;			/* pointer to next cast in linked list */
+  struct swig_cast_info  *prev;			/* pointer to the previous cast */
+} swig_cast_info;
+
+/* Structure used to store module information
+ * Each module generates one structure like this, and the runtime collects
+ * all of these structures and stores them in a circularly linked list.*/
+typedef struct swig_module_info {
+  swig_type_info         **types;		/* Array of pointers to swig_type_info structures that are in this module */
+  size_t                 size;		        /* Number of types in this module */
+  struct swig_module_info *next;		/* Pointer to next element in circularly linked list */
+  swig_type_info         **type_initial;	/* Array of initially generated type structures */
+  swig_cast_info         **cast_initial;	/* Array of initially generated casting structures */
+  void                    *clientdata;		/* Language specific module data */
+} swig_module_info;
+
+/*
+  Compare two type names skipping the space characters, therefore
+  "char*" == "char *" and "Class<int>" == "Class<int >", etc.
+
+  Return 0 when the two name types are equivalent, as in
+  strncmp, but skipping ' '.
+*/
+SWIGRUNTIME int
+SWIG_TypeNameComp(const char *f1, const char *l1,
+		  const char *f2, const char *l2) {
+  for (;(f1 != l1) && (f2 != l2); ++f1, ++f2) {
+    while ((*f1 == ' ') && (f1 != l1)) ++f1;
+    while ((*f2 == ' ') && (f2 != l2)) ++f2;
+    if (*f1 != *f2) return (*f1 > *f2) ? 1 : -1;
+  }
+  return (int)((l1 - f1) - (l2 - f2));
+}
+
+/*
+  Check type equivalence in a name list like <name1>|<name2>|...
+  Return 0 if equal, -1 if nb < tb, 1 if nb > tb
+*/
+SWIGRUNTIME int
+SWIG_TypeCmp(const char *nb, const char *tb) {
+  int equiv = 1;
+  const char* te = tb + strlen(tb);
+  const char* ne = nb;
+  while (equiv != 0 && *ne) {
+    for (nb = ne; *ne; ++ne) {
+      if (*ne == '|') break;
+    }
+    equiv = SWIG_TypeNameComp(nb, ne, tb, te);
+    if (*ne) ++ne;
+  }
+  return equiv;
+}
+
+/*
+  Check type equivalence in a name list like <name1>|<name2>|...
+  Return 0 if not equal, 1 if equal
+*/
+SWIGRUNTIME int
+SWIG_TypeEquiv(const char *nb, const char *tb) {
+  return SWIG_TypeCmp(nb, tb) == 0 ? 1 : 0;
+}
+
+/*
+  Check the typename
+*/
+SWIGRUNTIME swig_cast_info *
+SWIG_TypeCheck(const char *c, swig_type_info *ty) {
+  if (ty) {
+    swig_cast_info *iter = ty->cast;
+    while (iter) {
+      if (strcmp(iter->type->name, c) == 0) {
+        if (iter == ty->cast)
+          return iter;
+        /* Move iter to the top of the linked list */
+        iter->prev->next = iter->next;
+        if (iter->next)
+          iter->next->prev = iter->prev;
+        iter->next = ty->cast;
+        iter->prev = 0;
+        if (ty->cast) ty->cast->prev = iter;
+        ty->cast = iter;
+        return iter;
+      }
+      iter = iter->next;
+    }
+  }
+  return 0;
+}
+
+/*
+  Identical to SWIG_TypeCheck, except strcmp is replaced with a pointer comparison
+*/
+SWIGRUNTIME swig_cast_info *
+SWIG_TypeCheckStruct(swig_type_info *from, swig_type_info *ty) {
+  if (ty) {
+    swig_cast_info *iter = ty->cast;
+    while (iter) {
+      if (iter->type == from) {
+        if (iter == ty->cast)
+          return iter;
+        /* Move iter to the top of the linked list */
+        iter->prev->next = iter->next;
+        if (iter->next)
+          iter->next->prev = iter->prev;
+        iter->next = ty->cast;
+        iter->prev = 0;
+        if (ty->cast) ty->cast->prev = iter;
+        ty->cast = iter;
+        return iter;
+      }
+      iter = iter->next;
+    }
+  }
+  return 0;
+}
+
+/*
+  Cast a pointer up an inheritance hierarchy
+*/
+SWIGRUNTIMEINLINE void *
+SWIG_TypeCast(swig_cast_info *ty, void *ptr, int *newmemory) {
+  return ((!ty) || (!ty->converter)) ? ptr : (*ty->converter)(ptr, newmemory);
+}
+
+/*
+   Dynamic pointer casting. Down an inheritance hierarchy
+*/
+SWIGRUNTIME swig_type_info *
+SWIG_TypeDynamicCast(swig_type_info *ty, void **ptr) {
+  swig_type_info *lastty = ty;
+  if (!ty || !ty->dcast) return ty;
+  while (ty && (ty->dcast)) {
+    ty = (*ty->dcast)(ptr);
+    if (ty) lastty = ty;
+  }
+  return lastty;
+}
+
+/*
+  Return the name associated with this type
+*/
+SWIGRUNTIMEINLINE const char *
+SWIG_TypeName(const swig_type_info *ty) {
+  return ty->name;
+}
+
+/*
+  Return the pretty name associated with this type,
+  that is an unmangled type name in a form presentable to the user.
+*/
+SWIGRUNTIME const char *
+SWIG_TypePrettyName(const swig_type_info *type) {
+  /* The "str" field contains the equivalent pretty names of the
+     type, separated by vertical-bar characters.  We choose
+     to print the last name, as it is often (?) the most
+     specific. */
+  if (!type) return NULL;
+  if (type->str != NULL) {
+    const char *last_name = type->str;
+    const char *s;
+    for (s = type->str; *s; s++)
+      if (*s == '|') last_name = s+1;
+    return last_name;
+  }
+  else
+    return type->name;
+}
+
+/*
+   Set the clientdata field for a type
+*/
+SWIGRUNTIME void
+SWIG_TypeClientData(swig_type_info *ti, void *clientdata) {
+  swig_cast_info *cast = ti->cast;
+  /* if (ti->clientdata == clientdata) return; */
+  ti->clientdata = clientdata;
+
+  while (cast) {
+    if (!cast->converter) {
+      swig_type_info *tc = cast->type;
+      if (!tc->clientdata) {
+	SWIG_TypeClientData(tc, clientdata);
+      }
+    }
+    cast = cast->next;
+  }
+}
+SWIGRUNTIME void
+SWIG_TypeNewClientData(swig_type_info *ti, void *clientdata) {
+  SWIG_TypeClientData(ti, clientdata);
+  ti->owndata = 1;
+}
+
+/*
+  Search for a swig_type_info structure only by mangled name
+  Search is a O(log #types)
+
+  We start searching at module start, and finish searching when start == end.
+  Note: if start == end at the beginning of the function, we go all the way around
+  the circular list.
+*/
+SWIGRUNTIME swig_type_info *
+SWIG_MangledTypeQueryModule(swig_module_info *start,
+                            swig_module_info *end,
+		            const char *name) {
+  swig_module_info *iter = start;
+  do {
+    if (iter->size) {
+      size_t l = 0;
+      size_t r = iter->size - 1;
+      do {
+	/* since l+r >= 0, we can (>> 1) instead (/ 2) */
+	size_t i = (l + r) >> 1;
+	const char *iname = iter->types[i]->name;
+	if (iname) {
+	  int compare = strcmp(name, iname);
+	  if (compare == 0) {
+	    return iter->types[i];
+	  } else if (compare < 0) {
+	    if (i) {
+	      r = i - 1;
+	    } else {
+	      break;
+	    }
+	  } else if (compare > 0) {
+	    l = i + 1;
+	  }
+	} else {
+	  break; /* should never happen */
+	}
+      } while (l <= r);
+    }
+    iter = iter->next;
+  } while (iter != end);
+  return 0;
+}
+
+/*
+  Search for a swig_type_info structure for either a mangled name or a human readable name.
+  It first searches the mangled names of the types, which is a O(log #types)
+  If a type is not found it then searches the human readable names, which is O(#types).
+
+  We start searching at module start, and finish searching when start == end.
+  Note: if start == end at the beginning of the function, we go all the way around
+  the circular list.
+*/
+SWIGRUNTIME swig_type_info *
+SWIG_TypeQueryModule(swig_module_info *start,
+                     swig_module_info *end,
+		     const char *name) {
+  /* STEP 1: Search the name field using binary search */
+  swig_type_info *ret = SWIG_MangledTypeQueryModule(start, end, name);
+  if (ret) {
+    return ret;
+  } else {
+    /* STEP 2: If the type hasn't been found, do a complete search
+       of the str field (the human readable name) */
+    swig_module_info *iter = start;
+    do {
+      size_t i = 0;
+      for (; i < iter->size; ++i) {
+	if (iter->types[i]->str && (SWIG_TypeEquiv(iter->types[i]->str, name)))
+	  return iter->types[i];
+      }
+      iter = iter->next;
+    } while (iter != end);
+  }
+
+  /* neither found a match */
+  return 0;
+}
+
+/*
+   Pack binary data into a string
+*/
+SWIGRUNTIME char *
+SWIG_PackData(char *c, void *ptr, size_t sz) {
+  static const char hex[17] = "0123456789abcdef";
+  const unsigned char *u = (unsigned char *) ptr;
+  const unsigned char *eu =  u + sz;
+  for (; u != eu; ++u) {
+    unsigned char uu = *u;
+    *(c++) = hex[(uu & 0xf0) >> 4];
+    *(c++) = hex[uu & 0xf];
+  }
+  return c;
+}
+
+/*
+   Unpack binary data from a string
+*/
+SWIGRUNTIME const char *
+SWIG_UnpackData(const char *c, void *ptr, size_t sz) {
+  unsigned char *u = (unsigned char *) ptr;
+  const unsigned char *eu = u + sz;
+  for (; u != eu; ++u) {
+    char d = *(c++);
+    unsigned char uu;
+    if ((d >= '0') && (d <= '9'))
+      uu = (unsigned char)((d - '0') << 4);
+    else if ((d >= 'a') && (d <= 'f'))
+      uu = (unsigned char)((d - ('a'-10)) << 4);
+    else
+      return (char *) 0;
+    d = *(c++);
+    if ((d >= '0') && (d <= '9'))
+      uu |= (unsigned char)(d - '0');
+    else if ((d >= 'a') && (d <= 'f'))
+      uu |= (unsigned char)(d - ('a'-10));
+    else
+      return (char *) 0;
+    *u = uu;
+  }
+  return c;
+}
+
+/*
+   Pack 'void *' into a string buffer.
+*/
+SWIGRUNTIME char *
+SWIG_PackVoidPtr(char *buff, void *ptr, const char *name, size_t bsz) {
+  char *r = buff;
+  if ((2*sizeof(void *) + 2) > bsz) return 0;
+  *(r++) = '_';
+  r = SWIG_PackData(r,&ptr,sizeof(void *));
+  if (strlen(name) + 1 > (bsz - (r - buff))) return 0;
+  strcpy(r,name);
+  return buff;
+}
+
+SWIGRUNTIME const char *
+SWIG_UnpackVoidPtr(const char *c, void **ptr, const char *name) {
+  if (*c != '_') {
+    if (strcmp(c,"NULL") == 0) {
+      *ptr = (void *) 0;
+      return name;
+    } else {
+      return 0;
+    }
+  }
+  return SWIG_UnpackData(++c,ptr,sizeof(void *));
+}
+
+SWIGRUNTIME char *
+SWIG_PackDataName(char *buff, void *ptr, size_t sz, const char *name, size_t bsz) {
+  char *r = buff;
+  size_t lname = (name ? strlen(name) : 0);
+  if ((2*sz + 2 + lname) > bsz) return 0;
+  *(r++) = '_';
+  r = SWIG_PackData(r,ptr,sz);
+  if (lname) {
+    strncpy(r,name,lname+1);
+  } else {
+    *r = 0;
+  }
+  return buff;
+}
+
+SWIGRUNTIME const char *
+SWIG_UnpackDataName(const char *c, void *ptr, size_t sz, const char *name) {
+  if (*c != '_') {
+    if (strcmp(c,"NULL") == 0) {
+      memset(ptr,0,sz);
+      return name;
+    } else {
+      return 0;
+    }
+  }
+  return SWIG_UnpackData(++c,ptr,sz);
+}
+
+#ifdef __cplusplus
+}
+#endif
+
+/*  Errors in SWIG */
+#define  SWIG_UnknownError    	   -1
+#define  SWIG_IOError        	   -2
+#define  SWIG_RuntimeError   	   -3
+#define  SWIG_IndexError     	   -4
+#define  SWIG_TypeError      	   -5
+#define  SWIG_DivisionByZero 	   -6
+#define  SWIG_OverflowError  	   -7
+#define  SWIG_SyntaxError    	   -8
+#define  SWIG_ValueError     	   -9
+#define  SWIG_SystemError    	   -10
+#define  SWIG_AttributeError 	   -11
+#define  SWIG_MemoryError    	   -12
+#define  SWIG_NullReferenceError   -13
+
+
+
+#ifdef __cplusplus
+/* Needed on some windows machines---since MS plays funny games with the header files under C++ */
+#include <math.h>
+#include <stdlib.h>
+extern "C" {
+#endif
+#include "EXTERN.h"
+#include "perl.h"
+#include "XSUB.h"
+
+/* Add in functionality missing in older versions of Perl. Much of this is based on Devel-PPPort on cpan. */
+
+/* Add PERL_REVISION, PERL_VERSION, PERL_SUBVERSION if missing */
+#ifndef PERL_REVISION
+#  if !defined(__PATCHLEVEL_H_INCLUDED__) && !(defined(PATCHLEVEL) && defined(SUBVERSION))
+#    define PERL_PATCHLEVEL_H_IMPLICIT
+#    include <patchlevel.h>
+#  endif
+#  if !(defined(PERL_VERSION) || (defined(SUBVERSION) && defined(PATCHLEVEL)))
+#    include <could_not_find_Perl_patchlevel.h>
+#  endif
+#  ifndef PERL_REVISION
+#    define PERL_REVISION       (5)
+#    define PERL_VERSION        PATCHLEVEL
+#    define PERL_SUBVERSION     SUBVERSION
+#  endif
+#endif
+
+#if defined(WIN32) && defined(PERL_OBJECT) && !defined(PerlIO_exportFILE)
+#define PerlIO_exportFILE(fh,fl) (FILE*)(fh)
+#endif
+
+#ifndef SvIOK_UV
+# define SvIOK_UV(sv)       (SvIOK(sv) && (SvUVX(sv) == SvIVX(sv)))
+#endif
+
+#ifndef SvUOK
+# define SvUOK(sv)           SvIOK_UV(sv)
+#endif
+
+#if ((PERL_VERSION < 4) || ((PERL_VERSION == 4) && (PERL_SUBVERSION <= 5)))
+#  define PL_sv_undef               sv_undef
+#  define PL_na	                    na
+#  define PL_errgv                  errgv
+#  define PL_sv_no                  sv_no
+#  define PL_sv_yes                 sv_yes
+#  define PL_markstack_ptr          markstack_ptr
+#endif
+
+#ifndef IVSIZE
+#  ifdef LONGSIZE
+#    define IVSIZE LONGSIZE
+#  else
+#    define IVSIZE 4 /* A bold guess, but the best we can make. */
+#  endif
+#endif
+
+#ifndef INT2PTR
+#  if (IVSIZE == PTRSIZE) && (UVSIZE == PTRSIZE)
+#    define PTRV                  UV
+#    define INT2PTR(any,d)        (any)(d)
+#  else
+#    if PTRSIZE == LONGSIZE
+#      define PTRV                unsigned long
+#    else
+#      define PTRV                unsigned
+#    endif
+#    define INT2PTR(any,d)        (any)(PTRV)(d)
+#  endif
+
+#  define NUM2PTR(any,d)  (any)(PTRV)(d)
+#  define PTR2IV(p)       INT2PTR(IV,p)
+#  define PTR2UV(p)       INT2PTR(UV,p)
+#  define PTR2NV(p)       NUM2PTR(NV,p)
+
+#  if PTRSIZE == LONGSIZE
+#    define PTR2ul(p)     (unsigned long)(p)
+#  else
+#    define PTR2ul(p)     INT2PTR(unsigned long,p)
+#  endif
+#endif /* !INT2PTR */
+
+#ifndef SvPV_nolen
+# define SvPV_nolen(x) SvPV(x,PL_na)
+#endif
+
+#ifndef get_sv
+#  define get_sv perl_get_sv
+#endif
+
+#ifndef ERRSV
+#  define ERRSV get_sv("@",FALSE)
+#endif
+
+#ifndef pTHX_
+#define pTHX_
+#endif   
+
+#include <string.h>
+#ifdef __cplusplus
+}
+#endif
+
+/* -----------------------------------------------------------------------------
+ * error manipulation
+ * ----------------------------------------------------------------------------- */
+
+SWIGINTERN const char*
+SWIG_Perl_ErrorType(int code) {
+  switch(code) {
+  case SWIG_MemoryError:
+    return "MemoryError";
+  case SWIG_IOError:
+    return "IOError";
+  case SWIG_RuntimeError:
+    return "RuntimeError";
+  case SWIG_IndexError:
+    return "IndexError";
+  case SWIG_TypeError:
+    return "TypeError";
+  case SWIG_DivisionByZero:
+    return "ZeroDivisionError";
+  case SWIG_OverflowError:
+    return "OverflowError";
+  case SWIG_SyntaxError:
+    return "SyntaxError";
+  case SWIG_ValueError:
+    return "ValueError";
+  case SWIG_SystemError:
+    return "SystemError";
+  case SWIG_AttributeError:
+    return "AttributeError";
+  default:
+    return "RuntimeError";
+  }
+}
+
+
+/* -----------------------------------------------------------------------------
+ * perlrun.swg
+ *
+ * This file contains the runtime support for Perl modules
+ * and includes code for managing global variables and pointer
+ * type checking.
+ * ----------------------------------------------------------------------------- */
+
+#ifdef PERL_OBJECT
+#define SWIG_PERL_OBJECT_DECL CPerlObj *SWIGUNUSEDPARM(pPerl),
+#define SWIG_PERL_OBJECT_CALL pPerl,
+#else
+#define SWIG_PERL_OBJECT_DECL
+#define SWIG_PERL_OBJECT_CALL
+#endif
+
+/* Common SWIG API */
+
+/* for raw pointers */
+#define SWIG_ConvertPtr(obj, pp, type, flags)           SWIG_Perl_ConvertPtr(SWIG_PERL_OBJECT_CALL obj, pp, type, flags)
+#define SWIG_ConvertPtrAndOwn(obj, pp, type, flags,own) SWIG_Perl_ConvertPtrAndOwn(SWIG_PERL_OBJECT_CALL obj, pp, type, flags, own)
+#define SWIG_NewPointerObj(p, type, flags)              SWIG_Perl_NewPointerObj(SWIG_PERL_OBJECT_CALL p, type, flags)
+#define swig_owntype                                    int
+
+/* for raw packed data */
+#define SWIG_ConvertPacked(obj, p, s, type)             SWIG_Perl_ConvertPacked(SWIG_PERL_OBJECT_CALL obj, p, s, type)
+#define SWIG_NewPackedObj(p, s, type)	                SWIG_Perl_NewPackedObj(SWIG_PERL_OBJECT_CALL p, s, type)
+
+/* for class or struct pointers */
+#define SWIG_ConvertInstance(obj, pptr, type, flags)    SWIG_ConvertPtr(obj, pptr, type, flags)
+#define SWIG_NewInstanceObj(ptr, type, flags)           SWIG_NewPointerObj(ptr, type, flags)
+
+/* for C or C++ function pointers */
+#define SWIG_ConvertFunctionPtr(obj, pptr, type)        SWIG_ConvertPtr(obj, pptr, type, 0)
+#define SWIG_NewFunctionPtrObj(ptr, type)               SWIG_NewPointerObj(ptr, type, 0)
+
+/* for C++ member pointers, ie, member methods */
+#define SWIG_ConvertMember(obj, ptr, sz, ty)            SWIG_ConvertPacked(obj, ptr, sz, ty)
+#define SWIG_NewMemberObj(ptr, sz, type)                SWIG_NewPackedObj(ptr, sz, type)
+
+
+/* Runtime API */
+
+#define SWIG_GetModule(clientdata)                      SWIG_Perl_GetModule(clientdata)
+#define SWIG_SetModule(clientdata, pointer)             SWIG_Perl_SetModule(pointer)
+
+
+/* Error manipulation */
+
+#define SWIG_ErrorType(code)                            SWIG_Perl_ErrorType(code)               
+#define SWIG_Error(code, msg)            		sv_setpvf(get_sv("@", GV_ADD), "%s %s", SWIG_ErrorType(code), msg)
+#define SWIG_fail                        		goto fail						    
+
+/* Perl-specific SWIG API */
+
+#define SWIG_MakePtr(sv, ptr, type, flags)              SWIG_Perl_MakePtr(SWIG_PERL_OBJECT_CALL sv, ptr, type, flags)
+#define SWIG_MakePackedObj(sv, p, s, type)	        SWIG_Perl_MakePackedObj(SWIG_PERL_OBJECT_CALL sv, p, s, type)
+#define SWIG_SetError(str)                              SWIG_Error(SWIG_RuntimeError, str)
+
+
+#define SWIG_PERL_DECL_ARGS_1(arg1)                     (SWIG_PERL_OBJECT_DECL arg1)
+#define SWIG_PERL_CALL_ARGS_1(arg1)                     (SWIG_PERL_OBJECT_CALL arg1)
+#define SWIG_PERL_DECL_ARGS_2(arg1, arg2)               (SWIG_PERL_OBJECT_DECL arg1, arg2)
+#define SWIG_PERL_CALL_ARGS_2(arg1, arg2)               (SWIG_PERL_OBJECT_CALL arg1, arg2)
+
+/* -----------------------------------------------------------------------------
+ * pointers/data manipulation
+ * ----------------------------------------------------------------------------- */
+
+/* For backward compatibility only */
+#define SWIG_POINTER_EXCEPTION  0
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#define SWIG_OWNER   SWIG_POINTER_OWN
+#define SWIG_SHADOW  SWIG_OWNER << 1
+
+#define SWIG_MAYBE_PERL_OBJECT SWIG_PERL_OBJECT_DECL
+
+/* SWIG Perl macros */
+
+/* Macro to declare an XS function */
+#ifndef XSPROTO
+#   define XSPROTO(name) void name(pTHX_ CV* cv)
+#endif
+
+/* Macro to call an XS function */
+#ifdef PERL_OBJECT 
+#  define SWIG_CALLXS(_name) _name(cv,pPerl) 
+#else 
+#  ifndef MULTIPLICITY 
+#    define SWIG_CALLXS(_name) _name(cv) 
+#  else 
+#    define SWIG_CALLXS(_name) _name(PERL_GET_THX, cv) 
+#  endif 
+#endif 
+
+#ifdef PERL_OBJECT
+#define MAGIC_PPERL  CPerlObj *pPerl = (CPerlObj *) this;
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+typedef int (CPerlObj::*SwigMagicFunc)(SV *, MAGIC *);
+#ifdef __cplusplus
+}
+#endif
+
+#define SWIG_MAGIC(a,b) (SV *a, MAGIC *b)
+#define SWIGCLASS_STATIC
+
+#else /* PERL_OBJECT */
+
+#define MAGIC_PPERL
+#define SWIGCLASS_STATIC static SWIGUNUSED
+
+#ifndef MULTIPLICITY
+#define SWIG_MAGIC(a,b) (SV *a, MAGIC *b)
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+typedef int (*SwigMagicFunc)(SV *, MAGIC *);
+#ifdef __cplusplus
+}
+#endif
+
+#else /* MULTIPLICITY */
+
+#define SWIG_MAGIC(a,b) (struct interpreter *interp, SV *a, MAGIC *b)
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+typedef int (*SwigMagicFunc)(struct interpreter *, SV *, MAGIC *);
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* MULTIPLICITY */
+#endif /* PERL_OBJECT */
+
+#  ifdef PERL_OBJECT
+#    define SWIG_croak_null() SWIG_Perl_croak_null(pPerl)
+static void SWIGUNUSED SWIG_Perl_croak_null(CPerlObj *pPerl)
+#  else
+static void SWIGUNUSED SWIG_croak_null()
+#  endif
+{
+  SV *err = get_sv("@", GV_ADD);
+#  if (PERL_VERSION < 6)
+  croak("%_", err);
+#  else
+  if (sv_isobject(err))
+    croak(0);
+  else
+    croak("%s", SvPV_nolen(err));
+#  endif
+}
+
+
+/* 
+   Define how strict is the cast between strings and integers/doubles
+   when overloading between these types occurs.
+   
+   The default is making it as strict as possible by using SWIG_AddCast
+   when needed.
+   
+   You can use -DSWIG_PERL_NO_STRICT_STR2NUM at compilation time to
+   disable the SWIG_AddCast, making the casting between string and
+   numbers less strict.
+
+   In the end, we try to solve the overloading between strings and
+   numerical types in the more natural way, but if you can avoid it,
+   well, avoid it using %rename, for example.
+*/
+#ifndef SWIG_PERL_NO_STRICT_STR2NUM
+# ifndef SWIG_PERL_STRICT_STR2NUM
+#  define SWIG_PERL_STRICT_STR2NUM
+# endif
+#endif
+#ifdef SWIG_PERL_STRICT_STR2NUM
+/* string takes precedence */
+#define SWIG_Str2NumCast(x) SWIG_AddCast(x)  
+#else
+/* number takes precedence */
+#define SWIG_Str2NumCast(x) x
+#endif
+
+
+
+#include <stdlib.h>
+
+SWIGRUNTIME const char *
+SWIG_Perl_TypeProxyName(const swig_type_info *type) {
+  if (!type) return NULL;
+  if (type->clientdata != NULL) {
+    return (const char*) type->clientdata;
+  } 
+  else {
+    return type->name;
+  }
+}
+
+/* Identical to SWIG_TypeCheck, except for strcmp comparison */
+SWIGRUNTIME swig_cast_info *
+SWIG_TypeProxyCheck(const char *c, swig_type_info *ty) {
+  if (ty) {
+    swig_cast_info *iter = ty->cast;
+    while (iter) {
+      if (strcmp(SWIG_Perl_TypeProxyName(iter->type), c) == 0) {
+        if (iter == ty->cast)
+          return iter;
+        /* Move iter to the top of the linked list */
+        iter->prev->next = iter->next;
+        if (iter->next)
+          iter->next->prev = iter->prev;
+        iter->next = ty->cast;
+        iter->prev = 0;
+        if (ty->cast) ty->cast->prev = iter;
+        ty->cast = iter;
+        return iter;
+      }
+      iter = iter->next;
+    }
+  }
+  return 0;
+}
+
+/* Function for getting a pointer value */
+
+SWIGRUNTIME int
+SWIG_Perl_ConvertPtrAndOwn(SWIG_MAYBE_PERL_OBJECT SV *sv, void **ptr, swig_type_info *_t, int flags, int *own) {
+  swig_cast_info *tc;
+  void *voidptr = (void *)0;
+  SV *tsv = 0;
+
+  if (own)
+    *own = 0;
+
+  /* If magical, apply more magic */
+  if (SvGMAGICAL(sv))
+    mg_get(sv);
+
+  /* Check to see if this is an object */
+  if (sv_isobject(sv)) {
+    IV tmp = 0;
+    tsv = (SV*) SvRV(sv);
+    if ((SvTYPE(tsv) == SVt_PVHV)) {
+      MAGIC *mg;
+      if (SvMAGICAL(tsv)) {
+        mg = mg_find(tsv,'P');
+        if (mg) {
+          sv = mg->mg_obj;
+          if (sv_isobject(sv)) {
+	    tsv = (SV*)SvRV(sv);
+            tmp = SvIV(tsv);
+          }
+        }
+      } else {
+        return SWIG_ERROR;
+      }
+    } else {
+      tmp = SvIV(tsv);
+    }
+    voidptr = INT2PTR(void *,tmp);
+  } else if (! SvOK(sv)) {            /* Check for undef */
+    *(ptr) = (void *) 0;
+    return SWIG_OK;
+  } else if (SvTYPE(sv) == SVt_RV) {  /* Check for NULL pointer */
+    if (!SvROK(sv)) {
+      /* In Perl 5.12 and later, SVt_RV == SVt_IV, so sv could be a valid integer value.  */
+      if (SvIOK(sv)) {
+        return SWIG_ERROR;
+      } else {
+        /* NULL pointer (reference to undef). */
+        *(ptr) = (void *) 0;
+        return SWIG_OK;
+      }
+    } else {
+      return SWIG_ERROR;
+    }
+  } else {                            /* Don't know what it is */
+    return SWIG_ERROR;
+  }
+  if (_t) {
+    /* Now see if the types match */
+    char *_c = HvNAME(SvSTASH(SvRV(sv)));
+    tc = SWIG_TypeProxyCheck(_c,_t);
+#ifdef SWIG_DIRECTORS
+    if (!tc && !sv_derived_from(sv,SWIG_Perl_TypeProxyName(_t))) {
+#else
+    if (!tc) {
+#endif
+      return SWIG_ERROR;
+    }
+    {
+      int newmemory = 0;
+      *ptr = SWIG_TypeCast(tc,voidptr,&newmemory);
+      if (newmemory == SWIG_CAST_NEW_MEMORY) {
+        assert(own); /* badly formed typemap which will lead to a memory leak - it must set and use own to delete *ptr */
+        if (own)
+          *own = *own | SWIG_CAST_NEW_MEMORY;
+      }
+    }
+  } else {
+    *ptr = voidptr;
+  }
+
+  /* 
+   *  DISOWN implementation: we need a perl guru to check this one.
+   */
+  if (tsv && (flags & SWIG_POINTER_DISOWN)) {
+    /* 
+     *  almost copy paste code from below SWIG_POINTER_OWN setting
+     */
+    SV *obj = sv;
+    HV *stash = SvSTASH(SvRV(obj));
+    GV *gv = *(GV**)hv_fetch(stash, "OWNER", 5, TRUE);
+    if (isGV(gv)) {
+      HV *hv = GvHVn(gv);
+      /*
+       * To set ownership (see below), a newSViv(1) entry is added. 
+       * Hence, to remove ownership, we delete the entry.
+       */
+      if (hv_exists_ent(hv, obj, 0)) {
+	hv_delete_ent(hv, obj, 0, 0);
+      }
+    }
+  }
+  return SWIG_OK;
+}
+
+SWIGRUNTIME int
+SWIG_Perl_ConvertPtr(SWIG_MAYBE_PERL_OBJECT SV *sv, void **ptr, swig_type_info *_t, int flags) {
+  return SWIG_Perl_ConvertPtrAndOwn(sv, ptr, _t, flags, 0);
+}
+
+SWIGRUNTIME void
+SWIG_Perl_MakePtr(SWIG_MAYBE_PERL_OBJECT SV *sv, void *ptr, swig_type_info *t, int flags) {
+  if (ptr && (flags & (SWIG_SHADOW | SWIG_POINTER_OWN))) {
+    SV *self;
+    SV *obj=newSV(0);
+    HV *hash=newHV();
+    HV *stash;
+    sv_setref_pv(obj, SWIG_Perl_TypeProxyName(t), ptr);
+    stash=SvSTASH(SvRV(obj));
+    if (flags & SWIG_POINTER_OWN) {
+      HV *hv;
+      GV *gv = *(GV**)hv_fetch(stash, "OWNER", 5, TRUE);
+      if (!isGV(gv))
+        gv_init(gv, stash, "OWNER", 5, FALSE);
+      hv=GvHVn(gv);
+      hv_store_ent(hv, obj, newSViv(1), 0);
+    }
+    sv_magic((SV *)hash, (SV *)obj, 'P', Nullch, 0);
+    SvREFCNT_dec(obj);
+    self=newRV_noinc((SV *)hash);
+    sv_setsv(sv, self);
+    SvREFCNT_dec((SV *)self);
+    sv_bless(sv, stash);
+  }
+  else {
+    sv_setref_pv(sv, SWIG_Perl_TypeProxyName(t), ptr);
+  }
+}
+
+SWIGRUNTIMEINLINE SV *
+SWIG_Perl_NewPointerObj(SWIG_MAYBE_PERL_OBJECT void *ptr, swig_type_info *t, int flags) {
+  SV *result = sv_newmortal();
+  SWIG_MakePtr(result, ptr, t, flags);
+  return result;
+}
+
+SWIGRUNTIME void
+SWIG_Perl_MakePackedObj(SWIG_MAYBE_PERL_OBJECT SV *sv, void *ptr, int sz, swig_type_info *type) {
+  char result[1024];
+  char *r = result;
+  if ((2*sz + 1 + strlen(SWIG_Perl_TypeProxyName(type))) > 1000) return;
+  *(r++) = '_';
+  r = SWIG_PackData(r,ptr,sz);
+  strcpy(r,SWIG_Perl_TypeProxyName(type));
+  sv_setpv(sv, result);
+}
+
+SWIGRUNTIME SV *
+SWIG_Perl_NewPackedObj(SWIG_MAYBE_PERL_OBJECT void *ptr, int sz, swig_type_info *type) {
+  SV *result = sv_newmortal();
+  SWIG_Perl_MakePackedObj(result, ptr, sz, type);
+  return result;
+}
+
+/* Convert a packed value value */
+SWIGRUNTIME int
+SWIG_Perl_ConvertPacked(SWIG_MAYBE_PERL_OBJECT SV *obj, void *ptr, int sz, swig_type_info *ty) {
+  swig_cast_info *tc;
+  const char  *c = 0;
+
+  if ((!obj) || (!SvOK(obj))) return SWIG_ERROR;
+  c = SvPV_nolen(obj);
+  /* Pointer values must start with leading underscore */
+  if (*c != '_') return SWIG_ERROR;
+  c++;
+  c = SWIG_UnpackData(c,ptr,sz);
+  if (ty) {
+    tc = SWIG_TypeCheck(c,ty);
+    if (!tc) return SWIG_ERROR;
+  }
+  return SWIG_OK;
+}
+
+
+/* Macros for low-level exception handling */
+#define SWIG_croak(x)    { SWIG_Error(SWIG_RuntimeError, x); SWIG_fail; }
+
+
+typedef XSPROTO(SwigPerlWrapper);
+typedef SwigPerlWrapper *SwigPerlWrapperPtr;
+
+/* Structure for command table */
+typedef struct {
+  const char         *name;
+  SwigPerlWrapperPtr  wrapper;
+} swig_command_info;
+
+/* Information for constant table */
+
+#define SWIG_INT     1
+#define SWIG_FLOAT   2
+#define SWIG_STRING  3
+#define SWIG_POINTER 4
+#define SWIG_BINARY  5
+
+/* Constant information structure */
+typedef struct swig_constant_info {
+    int              type;
+    const char      *name;
+    long             lvalue;
+    double           dvalue;
+    void            *pvalue;
+    swig_type_info **ptype;
+} swig_constant_info;
+
+
+/* Structure for variable table */
+typedef struct {
+  const char   *name;
+  SwigMagicFunc   set;
+  SwigMagicFunc   get;
+  swig_type_info  **type;
+} swig_variable_info;
+
+/* Magic variable code */
+#ifndef PERL_OBJECT
+# ifdef __cplusplus
+#  define swig_create_magic(s,a,b,c) _swig_create_magic(s,const_cast<char*>(a),b,c)
+# else
+#  define swig_create_magic(s,a,b,c) _swig_create_magic(s,(char*)(a),b,c)
+# endif
+# ifndef MULTIPLICITY
+SWIGRUNTIME void _swig_create_magic(SV *sv, char *name, int (*set)(SV *, MAGIC *), int (*get)(SV *,MAGIC *)) 
+# else
+SWIGRUNTIME void _swig_create_magic(SV *sv, char *name, int (*set)(struct interpreter*, SV *, MAGIC *), int (*get)(struct interpreter*, SV *,MAGIC *)) 
+# endif
+#else
+#  define swig_create_magic(s,a,b,c) _swig_create_magic(pPerl,s,a,b,c)
+SWIGRUNTIME void _swig_create_magic(CPerlObj *pPerl, SV *sv, const char *name, int (CPerlObj::*set)(SV *, MAGIC *), int (CPerlObj::*get)(SV *, MAGIC *)) 
+#endif
+{
+  MAGIC *mg;
+  sv_magic(sv,sv,'U',name,strlen(name));
+  mg = mg_find(sv,'U');
+  mg->mg_virtual = (MGVTBL *) malloc(sizeof(MGVTBL));
+  mg->mg_virtual->svt_get = (SwigMagicFunc) get;
+  mg->mg_virtual->svt_set = (SwigMagicFunc) set;
+  mg->mg_virtual->svt_len = 0;
+  mg->mg_virtual->svt_clear = 0;
+  mg->mg_virtual->svt_free = 0;
+}
+
+
+SWIGRUNTIME swig_module_info *
+SWIG_Perl_GetModule(void *SWIGUNUSEDPARM(clientdata)) {
+  static void *type_pointer = (void *)0;
+  SV *pointer;
+
+  /* first check if pointer already created */
+  if (!type_pointer) {
+    pointer = get_sv("swig_runtime_data::type_pointer" SWIG_RUNTIME_VERSION SWIG_TYPE_TABLE_NAME, FALSE | GV_ADDMULTI);
+    if (pointer && SvOK(pointer)) {
+      type_pointer = INT2PTR(swig_type_info **, SvIV(pointer));
+    }
+  }
+
+  return (swig_module_info *) type_pointer;
+}
+
+SWIGRUNTIME void
+SWIG_Perl_SetModule(swig_module_info *module) {
+  SV *pointer;
+
+  /* create a new pointer */
+  pointer = get_sv("swig_runtime_data::type_pointer" SWIG_RUNTIME_VERSION SWIG_TYPE_TABLE_NAME, TRUE | GV_ADDMULTI);
+  sv_setiv(pointer, PTR2IV(module));
+}
+
+#ifdef __cplusplus
+}
+#endif
+
+/* Workaround perl5 global namespace pollution. Note that undefining library
+ * functions like fopen will not solve the problem on all platforms as fopen
+ * might be a macro on Windows but not necessarily on other operating systems. */
+#ifdef do_open
+  #undef do_open
+#endif
+#ifdef do_close
+  #undef do_close
+#endif
+#ifdef do_exec
+  #undef do_exec
+#endif
+#ifdef scalar
+  #undef scalar
+#endif
+#ifdef list
+  #undef list
+#endif
+#ifdef apply
+  #undef apply
+#endif
+#ifdef convert
+  #undef convert
+#endif
+#ifdef Error
+  #undef Error
+#endif
+#ifdef form
+  #undef form
+#endif
+#ifdef vform
+  #undef vform
+#endif
+#ifdef LABEL
+  #undef LABEL
+#endif
+#ifdef METHOD
+  #undef METHOD
+#endif
+#ifdef Move
+  #undef Move
+#endif
+#ifdef yylex
+  #undef yylex
+#endif
+#ifdef yyparse
+  #undef yyparse
+#endif
+#ifdef yyerror
+  #undef yyerror
+#endif
+#ifdef invert
+  #undef invert
+#endif
+#ifdef ref
+  #undef ref
+#endif
+#ifdef read
+  #undef read
+#endif
+#ifdef write
+  #undef write
+#endif
+#ifdef eof
+  #undef eof
+#endif
+#ifdef close
+  #undef close
+#endif
+#ifdef rewind
+  #undef rewind
+#endif
+#ifdef free
+  #undef free
+#endif
+#ifdef malloc
+  #undef malloc
+#endif
+#ifdef calloc
+  #undef calloc
+#endif
+#ifdef Stat
+  #undef Stat
+#endif
+#ifdef check
+  #undef check
+#endif
+#ifdef seekdir
+  #undef seekdir
+#endif
+#ifdef open
+  #undef open
+#endif
+#ifdef readdir
+  #undef readdir
+#endif
+#ifdef bind
+  #undef bind
+#endif
+#ifdef access
+  #undef access
+#endif
+#ifdef stat
+  #undef stat
+#endif
+#ifdef seed
+  #undef seed
+#endif
+
+#ifdef bool
+  /* Leave if macro is from C99 stdbool.h */
+  #ifndef __bool_true_false_are_defined
+    #undef bool
+  #endif
+#endif
+
+
+
+
+#define SWIG_exception_fail(code, msg) do { SWIG_Error(code, msg); SWIG_fail; } while(0) 
+
+#define SWIG_contract_assert(expr, msg) if (!(expr)) { SWIG_Error(SWIG_RuntimeError, msg); SWIG_fail; } else 
+
+
+
+/* -------- TYPES TABLE (BEGIN) -------- */
+
+#define SWIGTYPE_p_ABAC__Attribute swig_types[0]
+#define SWIGTYPE_p_ABAC__Context swig_types[1]
+#define SWIGTYPE_p_ABAC__Credential swig_types[2]
+#define SWIGTYPE_p_ABAC__ID swig_types[3]
+#define SWIGTYPE_p_ABAC__Role swig_types[4]
+#define SWIGTYPE_p_FILE swig_types[5]
+#define SWIGTYPE_p__abac_attribute_t swig_types[6]
+#define SWIGTYPE_p__abac_chunk_t swig_types[7]
+#define SWIGTYPE_p__abac_context_t swig_types[8]
+#define SWIGTYPE_p__abac_credential_t swig_types[9]
+#define SWIGTYPE_p__abac_id_cert_t swig_types[10]
+#define SWIGTYPE_p__abac_id_t swig_types[11]
+#define SWIGTYPE_p__abac_list_t swig_types[12]
+#define SWIGTYPE_p__abac_role_t swig_types[13]
+#define SWIGTYPE_p_abac_keyid_map_t swig_types[14]
+#define SWIGTYPE_p_abac_keyid_mapping_t swig_types[15]
+#define SWIGTYPE_p_bool swig_types[16]
+#define SWIGTYPE_p_char swig_types[17]
+#define SWIGTYPE_p_int swig_types[18]
+#define SWIGTYPE_p_p__abac_attribute_t swig_types[19]
+#define SWIGTYPE_p_p__abac_credential_t swig_types[20]
+#define SWIGTYPE_p_p__abac_id_cert_t swig_types[21]
+#define SWIGTYPE_p_p__abac_id_t swig_types[22]
+#define SWIGTYPE_p_size_type swig_types[23]
+#define SWIGTYPE_p_std__out_of_range swig_types[24]
+#define SWIGTYPE_p_std__vectorT_ABAC__Credential_t swig_types[25]
+#define SWIGTYPE_p_tm swig_types[26]
+#define SWIGTYPE_p_unsigned_char swig_types[27]
+#define SWIGTYPE_p_value_type swig_types[28]
+static swig_type_info *swig_types[30];
+static swig_module_info swig_module = {swig_types, 29, 0, 0, 0, 0};
+#define SWIG_TypeQuery(name) SWIG_TypeQueryModule(&swig_module, &swig_module, name)
+#define SWIG_MangledTypeQuery(name) SWIG_MangledTypeQueryModule(&swig_module, &swig_module, name)
+
+/* -------- TYPES TABLE (END) -------- */
+
+#define SWIG_init    boot_ABAC
+
+#define SWIG_name   "ABACc::boot_ABAC"
+#define SWIG_prefix "ABACc::"
+
+#define SWIGVERSION 0x030010 
+#define SWIG_VERSION SWIGVERSION
+
+
+#define SWIG_as_voidptr(a) const_cast< void * >(static_cast< const void * >(a)) 
+#define SWIG_as_voidptrptr(a) ((void)SWIG_as_voidptr(*a),reinterpret_cast< void** >(a)) 
+
+
+#include <stdexcept>
+
+
+#ifdef __cplusplus
+extern "C"
+#endif
+#ifndef PERL_OBJECT
+#ifndef MULTIPLICITY
+SWIGEXPORT void SWIG_init (CV* cv);
+#else
+SWIGEXPORT void SWIG_init (pTHXo_ CV* cv);
+#endif
+#else
+SWIGEXPORT void SWIG_init (CV *cv, CPerlObj *);
+#endif
+
+
+#include "abac.hh"
+using namespace ABAC;
+
+
+#include "SSL_keyid.h"
+
+
+SWIGINTERNINLINE SV *
+SWIG_FromCharPtrAndSize(const char* carray, size_t size)
+{
+  SV *obj = sv_newmortal();
+  if (carray) {
+    sv_setpvn(obj, carray, size);
+  } else {
+    sv_setsv(obj, &PL_sv_undef);
+  }
+  return obj;
+}
+
+
+SWIGINTERNINLINE SV * 
+SWIG_FromCharPtr(const char *cptr)
+{ 
+  return SWIG_FromCharPtrAndSize(cptr, (cptr ? strlen(cptr) : 0));
+}
+
+
+#include <stdexcept>
+
+
+#include <string>
+
+
+double SwigSvToNumber(SV* sv) {
+    return SvIOK(sv) ? double(SvIVX(sv)) : SvNVX(sv);
+}
+std::string SwigSvToString(SV* sv) {
+    STRLEN len;
+    char *ptr = SvPV(sv, len);
+    return std::string(ptr, len);
+}
+void SwigSvFromString(SV* sv, const std::string& s) {
+    sv_setpvn(sv,s.data(),s.size());
+}
+
+
+#include <vector>
+
+
+#include <algorithm>
+
+
+#include <limits.h>
+#if !defined(SWIG_NO_LLONG_MAX)
+# if !defined(LLONG_MAX) && defined(__GNUC__) && defined (__LONG_LONG_MAX__)
+#   define LLONG_MAX __LONG_LONG_MAX__
+#   define LLONG_MIN (-LLONG_MAX - 1LL)
+#   define ULLONG_MAX (LLONG_MAX * 2ULL + 1ULL)
+# endif
+#endif
+
+
+#include <stdlib.h>
+#ifdef _MSC_VER
+# ifndef strtoull
+#  define strtoull _strtoui64
+# endif
+# ifndef strtoll
+#  define strtoll _strtoi64
+# endif
+#endif
+
+
+SWIGINTERN int
+SWIG_AsVal_double SWIG_PERL_DECL_ARGS_2(SV *obj, double *val)
+{
+  if (SvNIOK(obj)) {
+    if (val) *val = SvNV(obj);
+    return SWIG_OK;
+  } else if (SvIOK(obj)) {
+    if (val) *val = (double) SvIV(obj);
+    return SWIG_AddCast(SWIG_OK);
+  } else {
+    const char *nptr = SvPV_nolen(obj);
+    if (nptr) {
+      char *endptr;
+      double v;
+      errno = 0;
+      v = strtod(nptr, &endptr);
+      if (errno == ERANGE) {
+	errno = 0;
+	return SWIG_OverflowError;
+      } else {
+	if (*endptr == '\0') {
+	  if (val) *val = v;
+	  return SWIG_Str2NumCast(SWIG_OK);
+	}
+      }
+    }
+  }
+  return SWIG_TypeError;
+}
+
+
+#include <float.h>
+
+
+#include <math.h>
+
+
+SWIGINTERNINLINE int
+SWIG_CanCastAsInteger(double *d, double min, double max) {
+  double x = *d;
+  if ((min <= x && x <= max)) {
+   double fx = floor(x);
+   double cx = ceil(x);
+   double rd =  ((x - fx) < 0.5) ? fx : cx; /* simple rint */
+   if ((errno == EDOM) || (errno == ERANGE)) {
+     errno = 0;
+   } else {
+     double summ, reps, diff;
+     if (rd < x) {
+       diff = x - rd;
+     } else if (rd > x) {
+       diff = rd - x;
+     } else {
+       return 1;
+     }
+     summ = rd + x;
+     reps = diff/summ;
+     if (reps < 8*DBL_EPSILON) {
+       *d = rd;
+       return 1;
+     }
+   }
+  }
+  return 0;
+}
+
+
+SWIGINTERN int
+SWIG_AsVal_unsigned_SS_long SWIG_PERL_DECL_ARGS_2(SV *obj, unsigned long *val) 
+{
+  if (SvUOK(obj)) {
+    UV v = SvUV(obj);
+    if (UVSIZE <= sizeof(*val) || v <= ULONG_MAX) {
+      if (val) *val = v;
+      return SWIG_OK;
+    }
+    return SWIG_OverflowError;
+  } else if (SvIOK(obj)) {
+    IV v = SvIV(obj);
+    if (v >= 0 && (IVSIZE <= sizeof(*val) || v <= ULONG_MAX)) {
+      if (val) *val = v;
+      return SWIG_OK;
+    }
+    return SWIG_OverflowError;
+  } else {
+    int dispatch = 0;
+    const char *nptr = SvPV_nolen(obj);
+    if (nptr) {
+      char *endptr;
+      unsigned long v;
+      errno = 0;
+      v = strtoul(nptr, &endptr,0);
+      if (errno == ERANGE) {
+	errno = 0;
+	return SWIG_OverflowError;
+      } else {
+	if (*endptr == '\0') {
+	  if (val) *val = v;
+	  return SWIG_Str2NumCast(SWIG_OK);
+	}
+      }
+    }
+    if (!dispatch) {
+      double d;
+      int res = SWIG_AddCast(SWIG_AsVal_double SWIG_PERL_CALL_ARGS_2(obj,&d));
+      if (SWIG_IsOK(res) && SWIG_CanCastAsInteger(&d, 0, ULONG_MAX)) {
+	if (val) *val = (unsigned long)(d);
+	return res;
+      }
+    }
+  }
+  return SWIG_TypeError;
+}
+
+
+SWIGINTERN int
+SWIG_AsVal_unsigned_SS_int SWIG_PERL_DECL_ARGS_2(SV * obj, unsigned int *val)
+{
+  unsigned long v;
+  int res = SWIG_AsVal_unsigned_SS_long SWIG_PERL_CALL_ARGS_2(obj, &v);
+  if (SWIG_IsOK(res)) {
+    if ((v > UINT_MAX)) {
+      return SWIG_OverflowError;
+    } else {
+      if (val) *val = static_cast< unsigned int >(v);
+    }
+  }  
+  return res;
+}
+
+
+SWIGINTERNINLINE SV *
+SWIG_From_unsigned_SS_long  SWIG_PERL_DECL_ARGS_1(unsigned long value)
+{
+  SV *sv;
+  if (UVSIZE >= sizeof(value) || value <= UV_MAX)
+    sv = newSVuv(value);
+  else
+    sv = newSVpvf("%lu", value);
+  return sv_2mortal(sv);
+}
+
+
+SWIGINTERNINLINE SV *
+SWIG_From_unsigned_SS_int  SWIG_PERL_DECL_ARGS_1(unsigned int value)
+{    
+  return SWIG_From_unsigned_SS_long  SWIG_PERL_CALL_ARGS_1(value);
+}
+
+
+SWIGINTERNINLINE SV *
+SWIG_From_bool  SWIG_PERL_DECL_ARGS_1(bool value)
+{
+  return boolSV(value);
+}
+
+
+SWIGINTERN int
+SWIG_AsVal_long SWIG_PERL_DECL_ARGS_2(SV *obj, long* val)
+{
+  if (SvUOK(obj)) {
+    UV v = SvUV(obj);
+    if (UVSIZE < sizeof(*val) || v <= LONG_MAX) {
+      if (val) *val = v;
+      return SWIG_OK;
+    }
+    return SWIG_OverflowError;
+  } else if (SvIOK(obj)) {
+    IV v = SvIV(obj);
+    if (IVSIZE <= sizeof(*val) || (v >= LONG_MIN && v <= LONG_MAX)) {
+      if(val) *val = v;
+      return SWIG_OK;
+    }
+    return SWIG_OverflowError;
+  } else {
+    int dispatch = 0;
+    const char *nptr = SvPV_nolen(obj);
+    if (nptr) {
+      char *endptr;
+      long v;
+      errno = 0;
+      v = strtol(nptr, &endptr,0);
+      if (errno == ERANGE) {
+	errno = 0;
+	return SWIG_OverflowError;
+      } else {
+	if (*endptr == '\0') {
+	  if (val) *val = v;
+	  return SWIG_Str2NumCast(SWIG_OK);
+	}
+      }
+    }
+    if (!dispatch) {
+      double d;
+      int res = SWIG_AddCast(SWIG_AsVal_double SWIG_PERL_CALL_ARGS_2(obj,&d));
+      if (SWIG_IsOK(res) && SWIG_CanCastAsInteger(&d, LONG_MIN, LONG_MAX)) {
+	if (val) *val = (long)(d);
+	return res;
+      }
+    }
+  }
+  return SWIG_TypeError;
+}
+
+
+SWIGINTERN int
+SWIG_AsVal_int SWIG_PERL_DECL_ARGS_2(SV * obj, int *val)
+{
+  long v;
+  int res = SWIG_AsVal_long SWIG_PERL_CALL_ARGS_2(obj, &v);
+  if (SWIG_IsOK(res)) {
+    if ((v < INT_MIN || v > INT_MAX)) {
+      return SWIG_OverflowError;
+    } else {
+      if (val) *val = static_cast< int >(v);
+    }
+  }  
+  return res;
+}
+
+SWIGINTERN ABAC::Credential &std_vector_Sl_ABAC_Credential_Sg__get(std::vector< ABAC::Credential > *self,int i){
+                int size = int(self->size());
+                if (i>=0 && i<size)
+                    return (*self)[i];
+                else
+                    throw std::out_of_range("vector index out of range");
+            }
+SWIGINTERN void std_vector_Sl_ABAC_Credential_Sg__set(std::vector< ABAC::Credential > *self,int i,ABAC::Credential const &x){
+                int size = int(self->size());
+                if (i>=0 && i<size)
+                    (*self)[i] = x;
+                else
+                    throw std::out_of_range("vector index out of range");
+            }
+
+SWIGINTERNINLINE SV *
+SWIG_From_long  SWIG_PERL_DECL_ARGS_1(long value)
+{
+  SV *sv;
+  if (IVSIZE >= sizeof(value) || (value >= IV_MIN && value <= IV_MAX))
+    sv = newSViv(value);
+  else
+    sv = newSVpvf("%ld", value);
+  return sv_2mortal(sv);
+}
+
+
+SWIGINTERNINLINE SV *
+SWIG_From_int  SWIG_PERL_DECL_ARGS_1(int value)
+{    
+  return SWIG_From_long  SWIG_PERL_CALL_ARGS_1(value);
+}
+
+
+SWIGINTERN swig_type_info*
+SWIG_pchar_descriptor(void)
+{
+  static int init = 0;
+  static swig_type_info* info = 0;
+  if (!init) {
+    info = SWIG_TypeQuery("_p_char");
+    init = 1;
+  }
+  return info;
+}
+
+
+SWIGINTERN int
+SWIG_AsCharPtrAndSize(SV *obj, char** cptr, size_t* psize, int *alloc)
+{
+  if (SvMAGICAL(obj)) {
+     SV *tmp = sv_newmortal();
+     SvSetSV(tmp, obj);
+     obj = tmp;
+  }
+  if (SvPOK(obj)) {
+    STRLEN len = 0;
+    char *cstr = SvPV(obj, len); 
+    size_t size = len + 1;
+    if (cptr)  {
+      if (alloc) {
+	if (*alloc == SWIG_NEWOBJ) {
+	  *cptr = reinterpret_cast< char* >(memcpy((new char[size]), cstr, sizeof(char)*(size)));
+	} else {
+	  *cptr = cstr;
+	  *alloc = SWIG_OLDOBJ;
+	}
+      }
+    }
+    if (psize) *psize = size;
+    return SWIG_OK;
+  } else {
+    swig_type_info* pchar_descriptor = SWIG_pchar_descriptor();
+    if (pchar_descriptor) {
+      char* vptr = 0; 
+      if (SWIG_ConvertPtr(obj, (void**)&vptr, pchar_descriptor, 0) == SWIG_OK) {
+	if (cptr) *cptr = vptr;
+	if (psize) *psize = vptr ? (strlen(vptr) + 1) : 0;
+	if (alloc) *alloc = SWIG_OLDOBJ;
+	return SWIG_OK;
+      }
+    }
+  }
+  return SWIG_TypeError;
+}
+
+
+
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#ifdef PERL_OBJECT
+#define MAGIC_CLASS _wrap_ABAC_var::
+class _wrap_ABAC_var : public CPerlObj {
+public:
+#else
+#define MAGIC_CLASS
+#endif
+SWIGCLASS_STATIC int swig_magic_readonly(pTHX_ SV *SWIGUNUSEDPARM(sv), MAGIC *SWIGUNUSEDPARM(mg)) {
+    MAGIC_PPERL
+    croak("Value is read-only.");
+    return 0;
+}
+
+
+#ifdef PERL_OBJECT
+};
+#endif
+
+#ifdef __cplusplus
+}
+#endif
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+XS(_wrap_SSL_keyid) {
+  {
+    void *arg1 = (void *) 0 ;
+    int res1 ;
+    int argvi = 0;
+    char *result = 0 ;
+    dXSARGS;
+    
+    if ((items < 1) || (items > 1)) {
+      SWIG_croak("Usage: SSL_keyid(ptr);");
+    }
+    res1 = SWIG_ConvertPtr(ST(0),SWIG_as_voidptrptr(&arg1), 0, 0);
+    if (!SWIG_IsOK(res1)) {
+      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SSL_keyid" "', argument " "1"" of type '" "void *""'"); 
+    }
+    result = (char *)SSL_keyid(arg1);
+    ST(argvi) = SWIG_FromCharPtr((const char *)result); argvi++ ;
+    
+    XSRETURN(argvi);
+  fail:
+    
+    SWIG_croak_null();
+  }
+}
+
+
+XS(_wrap_new_CredentialVector__SWIG_0) {
+  {
+    unsigned int arg1 ;
+    unsigned int val1 ;
+    int ecode1 = 0 ;
+    int argvi = 0;
+    std::vector< ABAC::Credential > *result = 0 ;
+    dXSARGS;
+    
+    if ((items < 1) || (items > 1)) {
+      SWIG_croak("Usage: new_CredentialVector(size);");
+    }
+    ecode1 = SWIG_AsVal_unsigned_SS_int SWIG_PERL_CALL_ARGS_2(ST(0), &val1);
+    if (!SWIG_IsOK(ecode1)) {
+      SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_CredentialVector" "', argument " "1"" of type '" "unsigned int""'");
+    } 
+    arg1 = static_cast< unsigned int >(val1);
+    {
+      try {
+        result = (std::vector< ABAC::Credential > *)new std::vector< ABAC::Credential >(arg1);
+      }
+      catch (std::invalid_argument) {
+        croak("std::invalid_argument");
+      }
+      catch (std::logic_error) {
+        croak("std::logic_error");
+      }
+    }
+    ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_ABAC__Credential_t, SWIG_OWNER | SWIG_SHADOW); argvi++ ;
+    
+    XSRETURN(argvi);
+  fail:
+    
+    SWIG_croak_null();
+  }
+}
+
+
+XS(_wrap_new_CredentialVector__SWIG_1) {
+  {
+    int argvi = 0;
+    std::vector< ABAC::Credential > *result = 0 ;
+    dXSARGS;
+    
+    if ((items < 0) || (items > 0)) {
+      SWIG_croak("Usage: new_CredentialVector();");
+    }
+    {
+      try {
+        result = (std::vector< ABAC::Credential > *)new std::vector< ABAC::Credential >();
+      }
+      catch (std::invalid_argument) {
+        croak("std::invalid_argument");
+      }
+      catch (std::logic_error) {
+        croak("std::logic_error");
+      }
+    }
+    ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_ABAC__Credential_t, SWIG_OWNER | SWIG_SHADOW); argvi++ ;
+    XSRETURN(argvi);
+  fail:
+    SWIG_croak_null();
+  }
+}
+
+
+XS(_wrap_new_CredentialVector__SWIG_2) {
+  {
+    unsigned int arg1 ;
+    ABAC::Credential *arg2 = 0 ;
+    unsigned int val1 ;
+    int ecode1 = 0 ;
+    void *argp2 ;
+    int res2 = 0 ;
+    int argvi = 0;
+    std::vector< ABAC::Credential > *result = 0 ;
+    dXSARGS;
+    
+    if ((items < 2) || (items > 2)) {
+      SWIG_croak("Usage: new_CredentialVector(size,value);");
+    }
+    ecode1 = SWIG_AsVal_unsigned_SS_int SWIG_PERL_CALL_ARGS_2(ST(0), &val1);
+    if (!SWIG_IsOK(ecode1)) {
+      SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_CredentialVector" "', argument " "1"" of type '" "unsigned int""'");
+    } 
+    arg1 = static_cast< unsigned int >(val1);
+    res2 = SWIG_ConvertPtr(ST(1), &argp2, SWIGTYPE_p_ABAC__Credential,  0 );
+    if (!SWIG_IsOK(res2)) {
+      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_CredentialVector" "', argument " "2"" of type '" "ABAC::Credential const &""'"); 
+    }
+    if (!argp2) {
+      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CredentialVector" "', argument " "2"" of type '" "ABAC::Credential const &""'"); 
+    }
+    arg2 = reinterpret_cast< ABAC::Credential * >(argp2);
+    {
+      try {
+        result = (std::vector< ABAC::Credential > *)new std::vector< ABAC::Credential >(arg1,(ABAC::Credential const &)*arg2);
+      }
+      catch (std::invalid_argument) {
+        croak("std::invalid_argument");
+      }
+      catch (std::logic_error) {
+        croak("std::logic_error");
+      }
+    }
+    ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_ABAC__Credential_t, SWIG_OWNER | SWIG_SHADOW); argvi++ ;
+    
+    
+    XSRETURN(argvi);
+  fail:
+    
+    
+    SWIG_croak_null();
+  }
+}
+
+
+XS(_wrap_new_CredentialVector__SWIG_3) {
+  {
+    std::vector< ABAC::Credential > *arg1 = 0 ;
+    std::vector< ABAC::Credential > temp1 ;
+    std::vector< ABAC::Credential > *v1 ;
+    int argvi = 0;
+    std::vector< ABAC::Credential > *result = 0 ;
+    dXSARGS;
+    
+    if ((items < 1) || (items > 1)) {
+      SWIG_croak("Usage: new_CredentialVector(std::vector< ABAC::Credential > const &);");
+    }
+    {
+      if (SWIG_ConvertPtr(ST(0),(void **) &v1, 
+          SWIGTYPE_p_std__vectorT_ABAC__Credential_t,1) != -1) {
+        arg1 = v1;
+      } else if (SvROK(ST(0))) {
+        AV *av = (AV *)SvRV(ST(0));
+        if (SvTYPE(av) != SVt_PVAV)
+        SWIG_croak("Type error in argument 1 of new_CredentialVector. "
+          "Expected an array of " "ABAC::Credential");
+        SV **tv;
+        I32 len = av_len(av) + 1;
+        ABAC::Credential* obj;
+        for (int i=0; i<len; i++) {
+          tv = av_fetch(av, i, 0);
+          if (SWIG_ConvertPtr(*tv, (void **)&obj, 
+              SWIGTYPE_p_ABAC__Credential,0) != -1) {
+            temp1.push_back(*obj);
+          } else {
+            SWIG_croak("Type error in argument 1 of "
+              "new_CredentialVector. "
+              "Expected an array of " "ABAC::Credential");
+          }
+        }
+        arg1 = &temp1;
+      } else {
+        SWIG_croak("Type error in argument 1 of new_CredentialVector. "
+          "Expected an array of " "ABAC::Credential");
+      }
+    }
+    {
+      try {
+        result = (std::vector< ABAC::Credential > *)new std::vector< ABAC::Credential >((std::vector< ABAC::Credential > const &)*arg1);
+      }
+      catch (std::invalid_argument) {
+        croak("std::invalid_argument");
+      }
+      catch (std::logic_error) {
+        croak("std::logic_error");
+      }
+    }
+    ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_ABAC__Credential_t, SWIG_OWNER | SWIG_SHADOW); argvi++ ;
+    
+    XSRETURN(argvi);
+  fail:
+    
+    SWIG_croak_null();
+  }
+}
+
+
+XS(_wrap_new_CredentialVector) {
+  dXSARGS;
+  
+  {
+    unsigned long _index = 0;
+    SWIG_TypeRank _rank = 0; 
+    if (items == 0) {
+      SWIG_TypeRank _ranki = 0;
+      SWIG_TypeRank _rankm = 0;
+      if (!_index || (_ranki < _rank)) {
+        _rank = _ranki; _index = 1;
+        if (_rank == _rankm) goto dispatch;
+      }
+    }
+    if (items == 1) {
+      SWIG_TypeRank _ranki = 0;
+      SWIG_TypeRank _rankm = 0;
+      SWIG_TypeRank _pi = 1;
+      int _v = 0;
+      {
+        {
+          int res = SWIG_AsVal_unsigned_SS_int SWIG_PERL_CALL_ARGS_2(ST(0), NULL);
+          _v = SWIG_CheckState(res);
+        }
+      }
+      if (!_v) goto check_2;
+      _ranki += _v*_pi;
+      _rankm += _pi;
+      _pi *= SWIG_MAXCASTRANK;
+      if (!_index || (_ranki < _rank)) {
+        _rank = _ranki; _index = 2;
+        if (_rank == _rankm) goto dispatch;
+      }
+    }
+  check_2:
+    
+    if (items == 1) {
+      SWIG_TypeRank _ranki = 0;
+      SWIG_TypeRank _rankm = 0;
+      SWIG_TypeRank _pi = 1;
+      int _v = 0;
+      {
+        {
+          {
+            /* wrapped vector? */
+            std::vector< ABAC::Credential >* v;
+            if (SWIG_ConvertPtr(ST(0),(void **) &v, 
+                SWIGTYPE_p_std__vectorT_ABAC__Credential_t,0) != -1) {
+              _v = 1;
+            } else if (SvROK(ST(0))) {
+              /* native sequence? */
+              AV *av = (AV *)SvRV(ST(0));
+              if (SvTYPE(av) == SVt_PVAV) {
+                I32 len = av_len(av) + 1;
+                if (len == 0) {
+                  /* an empty sequence can be of any type */
+                  _v = 1;
+                } else {
+                  /* check the first element only */
+                  ABAC::Credential* obj;
+                  SV **tv = av_fetch(av, 0, 0);
+                  if (SWIG_ConvertPtr(*tv, (void **)&obj, 
+                      SWIGTYPE_p_ABAC__Credential,0) != -1)
+                  _v = 1;
+                  else
+                  _v = 0;
+                }
+              }
+            } else {
+              _v = 0;
+            }
+          }
+        }
+      }
+      if (!_v) goto check_3;
+      _ranki += _v*_pi;
+      _rankm += _pi;
+      _pi *= SWIG_MAXCASTRANK;
+      if (!_index || (_ranki < _rank)) {
+        _rank = _ranki; _index = 3;
+        if (_rank == _rankm) goto dispatch;
+      }
+    }
+  check_3:
+    
+    if (items == 2) {
+      SWIG_TypeRank _ranki = 0;
+      SWIG_TypeRank _rankm = 0;
+      SWIG_TypeRank _pi = 1;
+      int _v = 0;
+      {
+        {
+          int res = SWIG_AsVal_unsigned_SS_int SWIG_PERL_CALL_ARGS_2(ST(0), NULL);
+          _v = SWIG_CheckState(res);
+        }
+      }
+      if (!_v) goto check_4;
+      _ranki += _v*_pi;
+      _rankm += _pi;
+      _pi *= SWIG_MAXCASTRANK;
+      {
+        void *vptr = 0;
+        int res = SWIG_ConvertPtr(ST(1), &vptr, SWIGTYPE_p_ABAC__Credential, 0);
+        _v = SWIG_CheckState(res);
+      }
+      if (!_v) goto check_4;
+      _ranki += _v*_pi;
+      _rankm += _pi;
+      _pi *= SWIG_MAXCASTRANK;
+      if (!_index || (_ranki < _rank)) {
+        _rank = _ranki; _index = 4;
+        if (_rank == _rankm) goto dispatch;
+      }
+    }
+  check_4:
+    
+  dispatch:
+    switch(_index) {
+    case 1:
+      PUSHMARK(MARK); SWIG_CALLXS(_wrap_new_CredentialVector__SWIG_1); return;
+    case 2:
+      PUSHMARK(MARK); SWIG_CALLXS(_wrap_new_CredentialVector__SWIG_0); return;
+    case 3:
+      PUSHMARK(MARK); SWIG_CALLXS(_wrap_new_CredentialVector__SWIG_3); return;
+    case 4:
+      PUSHMARK(MARK); SWIG_CALLXS(_wrap_new_CredentialVector__SWIG_2); return;
+    }
+  }
+  
+  croak("No matching function for overloaded 'new_CredentialVector'");
+  XSRETURN(0);
+}
+
+
+XS(_wrap_CredentialVector_size) {
+  {
+    std::vector< ABAC::Credential > *arg1 = (std::vector< ABAC::Credential > *) 0 ;
+    std::vector< ABAC::Credential > temp1 ;
+    std::vector< ABAC::Credential > *v1 ;
+    int argvi = 0;
+    unsigned int result;
+    dXSARGS;
+    
+    if ((items < 1) || (items > 1)) {
+      SWIG_croak("Usage: CredentialVector_size(self);");
+    }
+    {
+      if (SWIG_ConvertPtr(ST(0),(void **) &v1, 
+          SWIGTYPE_p_std__vectorT_ABAC__Credential_t,1) != -1) {
+        arg1 = v1;
+      } else if (SvROK(ST(0))) {
+        AV *av = (AV *)SvRV(ST(0));
+        if (SvTYPE(av) != SVt_PVAV)
+        SWIG_croak("Type error in argument 1 of CredentialVector_size. "
+          "Expected an array of " "ABAC::Credential");
+        SV **tv;
+        I32 len = av_len(av) + 1;
+        ABAC::Credential* obj;
+        for (int i=0; i<len; i++) {
+          tv = av_fetch(av, i, 0);
+          if (SWIG_ConvertPtr(*tv, (void **)&obj, 
+              SWIGTYPE_p_ABAC__Credential,0) != -1) {
+            temp1.push_back(*obj);
+          } else {
+            SWIG_croak("Type error in argument 1 of "
+              "CredentialVector_size. "
+              "Expected an array of " "ABAC::Credential");
+          }
+        }
+        arg1 = &temp1;
+      } else {
+        SWIG_croak("Type error in argument 1 of CredentialVector_size. "
+          "Expected an array of " "ABAC::Credential");
+      }
+    }
+    {
+      try {
+        result = (unsigned int)((std::vector< ABAC::Credential > const *)arg1)->size();
+      }
+      catch (std::invalid_argument) {
+        croak("std::invalid_argument");
+      }
+      catch (std::logic_error) {
+        croak("std::logic_error");
+      }
+    }
+    ST(argvi) = SWIG_From_unsigned_SS_int  SWIG_PERL_CALL_ARGS_1(static_cast< unsigned int >(result)); argvi++ ;
+    
+    XSRETURN(argvi);
+  fail:
+    
+    SWIG_croak_null();
+  }
+}
+
+
+XS(_wrap_CredentialVector_empty) {
+  {
+    std::vector< ABAC::Credential > *arg1 = (std::vector< ABAC::Credential > *) 0 ;
+    std::vector< ABAC::Credential > temp1 ;
+    std::vector< ABAC::Credential > *v1 ;
+    int argvi = 0;
+    bool result;
+    dXSARGS;
+    
+    if ((items < 1) || (items > 1)) {
+      SWIG_croak("Usage: CredentialVector_empty(self);");
+    }
+    {
+      if (SWIG_ConvertPtr(ST(0),(void **) &v1, 
+          SWIGTYPE_p_std__vectorT_ABAC__Credential_t,1) != -1) {
+        arg1 = v1;
+      } else if (SvROK(ST(0))) {
+        AV *av = (AV *)SvRV(ST(0));
+        if (SvTYPE(av) != SVt_PVAV)
+        SWIG_croak("Type error in argument 1 of CredentialVector_empty. "
+          "Expected an array of " "ABAC::Credential");
+        SV **tv;
+        I32 len = av_len(av) + 1;
+        ABAC::Credential* obj;
+        for (int i=0; i<len; i++) {
+          tv = av_fetch(av, i, 0);
+          if (SWIG_ConvertPtr(*tv, (void **)&obj, 
+              SWIGTYPE_p_ABAC__Credential,0) != -1) {
+            temp1.push_back(*obj);
+          } else {
+            SWIG_croak("Type error in argument 1 of "
+              "CredentialVector_empty. "
+              "Expected an array of " "ABAC::Credential");
+          }
+        }
+        arg1 = &temp1;
+      } else {
+        SWIG_croak("Type error in argument 1 of CredentialVector_empty. "
+          "Expected an array of " "ABAC::Credential");
+      }
+    }
+    {
+      try {
+        result = (bool)((std::vector< ABAC::Credential > const *)arg1)->empty();
+      }
+      catch (std::invalid_argument) {
+        croak("std::invalid_argument");
+      }
+      catch (std::logic_error) {
+        croak("std::logic_error");
+      }
+    }
+    ST(argvi) = SWIG_From_bool  SWIG_PERL_CALL_ARGS_1(static_cast< bool >(result)); argvi++ ;
+    
+    XSRETURN(argvi);
+  fail:
+    
+    SWIG_croak_null();
+  }
+}
+
+
+XS(_wrap_CredentialVector_clear) {
+  {
+    std::vector< ABAC::Credential > *arg1 = (std::vector< ABAC::Credential > *) 0 ;
+    void *argp1 = 0 ;
+    int res1 = 0 ;
+    int argvi = 0;
+    dXSARGS;
+    
+    if ((items < 1) || (items > 1)) {
+      SWIG_croak("Usage: CredentialVector_clear(self);");
+    }
+    res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_std__vectorT_ABAC__Credential_t, 0 |  0 );
+    if (!SWIG_IsOK(res1)) {
+      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CredentialVector_clear" "', argument " "1"" of type '" "std::vector< ABAC::Credential > *""'"); 
+    }
+    arg1 = reinterpret_cast< std::vector< ABAC::Credential > * >(argp1);
+    {
+      try {
+        (arg1)->clear();
+      }
+      catch (std::invalid_argument) {
+        croak("std::invalid_argument");
+      }
+      catch (std::logic_error) {
+        croak("std::logic_error");
+      }
+    }
+    ST(argvi) = sv_newmortal();
+    
+    XSRETURN(argvi);
+  fail:
+    
+    SWIG_croak_null();
+  }
+}
+
+
+XS(_wrap_CredentialVector_push) {
+  {
+    std::vector< ABAC::Credential > *arg1 = (std::vector< ABAC::Credential > *) 0 ;
+    ABAC::Credential *arg2 = 0 ;
+    void *argp1 = 0 ;
+    int res1 = 0 ;
+    void *argp2 ;
+    int res2 = 0 ;
+    int argvi = 0;
+    dXSARGS;
+    
+    if ((items < 2) || (items > 2)) {
+      SWIG_croak("Usage: CredentialVector_push(self,x);");
+    }
+    res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_std__vectorT_ABAC__Credential_t, 0 |  0 );
+    if (!SWIG_IsOK(res1)) {
+      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CredentialVector_push" "', argument " "1"" of type '" "std::vector< ABAC::Credential > *""'"); 
+    }
+    arg1 = reinterpret_cast< std::vector< ABAC::Credential > * >(argp1);
+    res2 = SWIG_ConvertPtr(ST(1), &argp2, SWIGTYPE_p_ABAC__Credential,  0 );
+    if (!SWIG_IsOK(res2)) {
+      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CredentialVector_push" "', argument " "2"" of type '" "ABAC::Credential const &""'"); 
+    }
+    if (!argp2) {
+      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CredentialVector_push" "', argument " "2"" of type '" "ABAC::Credential const &""'"); 
+    }
+    arg2 = reinterpret_cast< ABAC::Credential * >(argp2);
+    {
+      try {
+        (arg1)->push_back((ABAC::Credential const &)*arg2);
+      }
+      catch (std::invalid_argument) {
+        croak("std::invalid_argument");
+      }
+      catch (std::logic_error) {
+        croak("std::logic_error");
+      }
+    }
+    ST(argvi) = sv_newmortal();
+    
+    
+    XSRETURN(argvi);
+  fail:
+    
+    
+    SWIG_croak_null();
+  }
+}
+
+
+XS(_wrap_CredentialVector_get) {
+  {
+    std::vector< ABAC::Credential > *arg1 = (std::vector< ABAC::Credential > *) 0 ;
+    int arg2 ;
+    void *argp1 = 0 ;
+    int res1 = 0 ;
+    int val2 ;
+    int ecode2 = 0 ;
+    int argvi = 0;
+    ABAC::Credential *result = 0 ;
+    dXSARGS;
+    
+    if ((items < 2) || (items > 2)) {
+      SWIG_croak("Usage: CredentialVector_get(self,i);");
+    }
+    res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_std__vectorT_ABAC__Credential_t, 0 |  0 );
+    if (!SWIG_IsOK(res1)) {
+      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CredentialVector_get" "', argument " "1"" of type '" "std::vector< ABAC::Credential > *""'"); 
+    }
+    arg1 = reinterpret_cast< std::vector< ABAC::Credential > * >(argp1);
+    ecode2 = SWIG_AsVal_int SWIG_PERL_CALL_ARGS_2(ST(1), &val2);
+    if (!SWIG_IsOK(ecode2)) {
+      SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CredentialVector_get" "', argument " "2"" of type '" "int""'");
+    } 
+    arg2 = static_cast< int >(val2);
+    {
+      try {
+        try {
+          result = (ABAC::Credential *) &std_vector_Sl_ABAC_Credential_Sg__get(arg1,arg2);
+        }
+        catch(std::out_of_range &_e) {
+          sv_setsv(get_sv("@", GV_ADD), SWIG_NewPointerObj((new std::out_of_range(static_cast< const std::out_of_range& >(_e))),SWIGTYPE_p_std__out_of_range,SWIG_POINTER_OWN)); SWIG_fail ;
+        }
+        
+      }
+      catch (std::invalid_argument) {
+        croak("std::invalid_argument");
+      }
+      catch (std::logic_error) {
+        croak("std::logic_error");
+      }
+    }
+    ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ABAC__Credential, 0 | SWIG_SHADOW); argvi++ ;
+    
+    
+    XSRETURN(argvi);
+  fail:
+    
+    
+    SWIG_croak_null();
+  }
+}
+
+
+XS(_wrap_CredentialVector_set) {
+  {
+    std::vector< ABAC::Credential > *arg1 = (std::vector< ABAC::Credential > *) 0 ;
+    int arg2 ;
+    ABAC::Credential *arg3 = 0 ;
+    void *argp1 = 0 ;
+    int res1 = 0 ;
+    int val2 ;
+    int ecode2 = 0 ;
+    void *argp3 ;
+    int res3 = 0 ;
+    int argvi = 0;
+    dXSARGS;
+    
+    if ((items < 3) || (items > 3)) {
+      SWIG_croak("Usage: CredentialVector_set(self,i,x);");
+    }
+    res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_std__vectorT_ABAC__Credential_t, 0 |  0 );
+    if (!SWIG_IsOK(res1)) {
+      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CredentialVector_set" "', argument " "1"" of type '" "std::vector< ABAC::Credential > *""'"); 
+    }
+    arg1 = reinterpret_cast< std::vector< ABAC::Credential > * >(argp1);
+    ecode2 = SWIG_AsVal_int SWIG_PERL_CALL_ARGS_2(ST(1), &val2);
+    if (!SWIG_IsOK(ecode2)) {
+      SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CredentialVector_set" "', argument " "2"" of type '" "int""'");
+    } 
+    arg2 = static_cast< int >(val2);
+    res3 = SWIG_ConvertPtr(ST(2), &argp3, SWIGTYPE_p_ABAC__Credential,  0 );
+    if (!SWIG_IsOK(res3)) {
+      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "CredentialVector_set" "', argument " "3"" of type '" "ABAC::Credential const &""'"); 
+    }
+    if (!argp3) {
+      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CredentialVector_set" "', argument " "3"" of type '" "ABAC::Credential const &""'"); 
+    }
+    arg3 = reinterpret_cast< ABAC::Credential * >(argp3);
+    {
+      try {
+        try {
+          std_vector_Sl_ABAC_Credential_Sg__set(arg1,arg2,(ABAC::Credential const &)*arg3);
+        }
+        catch(std::out_of_range &_e) {
+          sv_setsv(get_sv("@", GV_ADD), SWIG_NewPointerObj((new std::out_of_range(static_cast< const std::out_of_range& >(_e))),SWIGTYPE_p_std__out_of_range,SWIG_POINTER_OWN)); SWIG_fail ;
+        }
+        
+      }
+      catch (std::invalid_argument) {
+        croak("std::invalid_argument");
+      }
+      catch (std::logic_error) {
+        croak("std::logic_error");
+      }
+    }
+    ST(argvi) = sv_newmortal();
+    
+    
+    
+    XSRETURN(argvi);
+  fail:
+    
+    
+    
+    SWIG_croak_null();
+  }
+}
+
+
+XS(_wrap_delete_CredentialVector) {
+  {
+    std::vector< ABAC::Credential > *arg1 = (std::vector< ABAC::Credential > *) 0 ;
+    void *argp1 = 0 ;
+    int res1 = 0 ;
+    int argvi = 0;
+    dXSARGS;
+    
+    if ((items < 1) || (items > 1)) {
+      SWIG_croak("Usage: delete_CredentialVector(self);");
+    }
+    res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_std__vectorT_ABAC__Credential_t, SWIG_POINTER_DISOWN |  0 );
+    if (!SWIG_IsOK(res1)) {
+      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CredentialVector" "', argument " "1"" of type '" "std::vector< ABAC::Credential > *""'"); 
+    }
+    arg1 = reinterpret_cast< std::vector< ABAC::Credential > * >(argp1);
+    {
+      try {
+        delete arg1;
+      }
+      catch (std::invalid_argument) {
+        croak("std::invalid_argument");
+      }
+      catch (std::logic_error) {
+        croak("std::logic_error");
+      }
+    }
+    ST(argvi) = sv_newmortal();
+    
+    XSRETURN(argvi);
+  fail:
+    
+    SWIG_croak_null();
+  }
+}
+
+
+XS(_wrap_abac_chunk_t_ptr_set) {
+  {
+    _abac_chunk_t *arg1 = (_abac_chunk_t *) 0 ;
+    unsigned char *arg2 = (unsigned char *) 0 ;
+    void *argp1 = 0 ;
+    int res1 = 0 ;
+    void *argp2 = 0 ;
+    int res2 = 0 ;
+    int argvi = 0;
+    dXSARGS;
+    
+    if ((items < 2) || (items > 2)) {
+      SWIG_croak("Usage: abac_chunk_t_ptr_set(self,ptr);");
+    }
+    res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p__abac_chunk_t, 0 |  0 );
+    if (!SWIG_IsOK(res1)) {
+      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "abac_chunk_t_ptr_set" "', argument " "1"" of type '" "_abac_chunk_t *""'"); 
+    }
+    arg1 = reinterpret_cast< _abac_chunk_t * >(argp1);
+    res2 = SWIG_ConvertPtr(ST(1), &argp2,SWIGTYPE_p_unsigned_char, SWIG_POINTER_DISOWN |  0 );
+    if (!SWIG_IsOK(res2)) {
+      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "abac_chunk_t_ptr_set" "', argument " "2"" of type '" "unsigned char *""'"); 
+    }
+    arg2 = reinterpret_cast< unsigned char * >(argp2);
+    if (arg1) (arg1)->ptr = arg2;
+    ST(argvi) = sv_newmortal();
+    
+    
+    XSRETURN(argvi);
+  fail:
+    
+    
+    SWIG_croak_null();
+  }
+}
+
+
+XS(_wrap_abac_chunk_t_ptr_get) {
+  {
+    _abac_chunk_t *arg1 = (_abac_chunk_t *) 0 ;
+    void *argp1 = 0 ;
+    int res1 = 0 ;
+    int argvi = 0;
+    unsigned char *result = 0 ;
+    dXSARGS;
+    
+    if ((items < 1) || (items > 1)) {
+      SWIG_croak("Usage: abac_chunk_t_ptr_get(self);");
+    }
+    res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p__abac_chunk_t, 0 |  0 );
+    if (!SWIG_IsOK(res1)) {
+      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "abac_chunk_t_ptr_get" "', argument " "1"" of type '" "_abac_chunk_t *""'"); 
+    }
+    arg1 = reinterpret_cast< _abac_chunk_t * >(argp1);
+    result = (unsigned char *) ((arg1)->ptr);
+    ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_unsigned_char, 0 | 0); argvi++ ;
+    
+    XSRETURN(argvi);
+  fail:
+    
+    SWIG_croak_null();
+  }
+}
+
+
+XS(_wrap_abac_chunk_t_len_set) {
+  {
+    _abac_chunk_t *arg1 = (_abac_chunk_t *) 0 ;
+    int arg2 ;
+    void *argp1 = 0 ;
+    int res1 = 0 ;
+    int val2 ;
+    int ecode2 = 0 ;
+    int argvi = 0;
+    dXSARGS;
+    
+    if ((items < 2) || (items > 2)) {
+      SWIG_croak("Usage: abac_chunk_t_len_set(self,len);");
+    }
+    res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p__abac_chunk_t, 0 |  0 );
+    if (!SWIG_IsOK(res1)) {
+      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "abac_chunk_t_len_set" "', argument " "1"" of type '" "_abac_chunk_t *""'"); 
+    }
+    arg1 = reinterpret_cast< _abac_chunk_t * >(argp1);
+    ecode2 = SWIG_AsVal_int SWIG_PERL_CALL_ARGS_2(ST(1), &val2);
+    if (!SWIG_IsOK(ecode2)) {
+      SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "abac_chunk_t_len_set" "', argument " "2"" of type '" "int""'");
+    } 
+    arg2 = static_cast< int >(val2);
+    if (arg1) (arg1)->len = arg2;
+    ST(argvi) = sv_newmortal();
+    
+    
+    XSRETURN(argvi);
+  fail:
+    
+    
+    SWIG_croak_null();
+  }
+}
+
+
+XS(_wrap_abac_chunk_t_len_get) {
+  {
+    _abac_chunk_t *arg1 = (_abac_chunk_t *) 0 ;
+    void *argp1 = 0 ;
+    int res1 = 0 ;
+    int argvi = 0;
+    int result;
+    dXSARGS;
+    
+    if ((items < 1) || (items > 1)) {
+      SWIG_croak("Usage: abac_chunk_t_len_get(self);");
+    }
+    res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p__abac_chunk_t, 0 |  0 );
+    if (!SWIG_IsOK(res1)) {
+      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "abac_chunk_t_len_get" "', argument " "1"" of type '" "_abac_chunk_t *""'"); 
+    }
+    arg1 = reinterpret_cast< _abac_chunk_t * >(argp1);
+    result = (int) ((arg1)->len);
+    ST(argvi) = SWIG_From_int  SWIG_PERL_CALL_ARGS_1(static_cast< int >(result)); argvi++ ;
+    
+    XSRETURN(argvi);
+  fail:
+    
+    SWIG_croak_null();
+  }
+}
+
+
+XS(_wrap_new_abac_chunk_t) {
+  {
+    int argvi = 0;
+    _abac_chunk_t *result = 0 ;
+    dXSARGS;
+    
+    if ((items < 0) || (items > 0)) {
+      SWIG_croak("Usage: new_abac_chunk_t();");
+    }
+    {
+      try {
+        result = (_abac_chunk_t *)new _abac_chunk_t();
+      }
+      catch (std::invalid_argument) {
+        croak("std::invalid_argument");
+      }
+      catch (std::logic_error) {
+        croak("std::logic_error");
+      }
+    }
+    ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__abac_chunk_t, SWIG_OWNER | SWIG_SHADOW); argvi++ ;
+    XSRETURN(argvi);
+  fail:
+    SWIG_croak_null();
+  }
+}
+
+
+XS(_wrap_delete_abac_chunk_t) {
+  {
+    _abac_chunk_t *arg1 = (_abac_chunk_t *) 0 ;
+    void *argp1 = 0 ;
+    int res1 = 0 ;
+    int argvi = 0;
+    dXSARGS;
+    
+    if ((items < 1) || (items > 1)) {
+      SWIG_croak("Usage: delete_abac_chunk_t(self);");
+    }
+    res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p__abac_chunk_t, SWIG_POINTER_DISOWN |  0 );
+    if (!SWIG_IsOK(res1)) {
+      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_abac_chunk_t" "', argument " "1"" of type '" "_abac_chunk_t *""'"); 
+    }
+    arg1 = reinterpret_cast< _abac_chunk_t * >(argp1);
+    {
+      try {
+        delete arg1;
+      }
+      catch (std::invalid_argument) {
+        croak("std::invalid_argument");
+      }
+      catch (std::logic_error) {
+        croak("std::logic_error");
+      }
+    }
+    ST(argvi) = sv_newmortal();
+    
+    XSRETURN(argvi);
+  fail:
+    
+    SWIG_croak_null();
+  }
+}
+
+
+XS(_wrap_abac_chunk_free) {
+  {
+    abac_chunk_t *arg1 = (abac_chunk_t *) 0 ;
+    void *argp1 = 0 ;
+    int res1 = 0 ;
+    int argvi = 0;
+    dXSARGS;
+    
+    if ((items < 1) || (items > 1)) {
+      SWIG_croak("Usage: abac_chunk_free(abac_chunk_t *);");
+    }
+    res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p__abac_chunk_t, 0 |  0 );
+    if (!SWIG_IsOK(res1)) {
+      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "abac_chunk_free" "', argument " "1"" of type '" "abac_chunk_t *""'"); 
+    }
+    arg1 = reinterpret_cast< abac_chunk_t * >(argp1);
+    {
+      try {
+        abac_chunk_free(arg1);
+      }
+      catch (std::invalid_argument) {
+        croak("std::invalid_argument");
+      }
+      catch (std::logic_error) {
+        croak("std::logic_error");
+      }
+    }
+    ST(argvi) = sv_newmortal();
+    
+    XSRETURN(argvi);
+  fail:
+    
+    SWIG_croak_null();
+  }
+}
+
+
+XS(_wrap_abac_context_new) {
+  {
+    int argvi = 0;
+    abac_context_t *result = 0 ;
+    dXSARGS;
+    
+    if ((items < 0) || (items > 0)) {
+      SWIG_croak("Usage: abac_context_new();");
+    }
+    {
+      try {
+        result = (abac_context_t *)abac_context_new();
+      }
+      catch (std::invalid_argument) {
+        croak("std::invalid_argument");
+      }
+      catch (std::logic_error) {
+        croak("std::logic_error");
+      }
+    }
+    ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__abac_context_t, 0 | 0); argvi++ ;
+    XSRETURN(argvi);
+  fail:
+    SWIG_croak_null();
+  }
+}
+
+
+XS(_wrap_abac_context_dup) {
+  {
+    abac_context_t *arg1 = (abac_context_t *) 0 ;
+    void *argp1 = 0 ;
+    int res1 = 0 ;
+    int argvi = 0;
+    abac_context_t *result = 0 ;
+    dXSARGS;
+    
+    if ((items < 1) || (items > 1)) {
+      SWIG_croak("Usage: abac_context_dup(ctx);");
+    }
+    res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p__abac_context_t, 0 |  0 );
+    if (!SWIG_IsOK(res1)) {
+      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "abac_context_dup" "', argument " "1"" of type '" "abac_context_t *""'"); 
+    }
+    arg1 = reinterpret_cast< abac_context_t * >(argp1);
+    {
+      try {
+        result = (abac_context_t *)abac_context_dup(arg1);
+      }
+      catch (std::invalid_argument) {
+        croak("std::invalid_argument");
+      }
+      catch (std::logic_error) {
+        croak("std::logic_error");
+      }
+    }
+    ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__abac_context_t, 0 | 0); argvi++ ;
+    
+    XSRETURN(argvi);
+  fail:
+    
+    SWIG_croak_null();
+  }
+}
+
+
+XS(_wrap_abac_context_free) {
+  {
+    abac_context_t *arg1 = (abac_context_t *) 0 ;
+    void *argp1 = 0 ;
+    int res1 = 0 ;
+    int argvi = 0;
+    dXSARGS;
+    
+    if ((items < 1) || (items > 1)) {
+      SWIG_croak("Usage: abac_context_free(ctx);");
+    }
+    res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p__abac_context_t, 0 |  0 );
+    if (!SWIG_IsOK(res1)) {
+      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "abac_context_free" "', argument " "1"" of type '" "abac_context_t *""'"); 
+    }
+    arg1 = reinterpret_cast< abac_context_t * >(argp1);
+    {
+      try {
+        abac_context_free(arg1);
+      }
+      catch (std::invalid_argument) {
+        croak("std::invalid_argument");
+      }
+      catch (std::logic_error) {
+        croak("std::logic_error");
+      }
+    }
+    ST(argvi) = sv_newmortal();
+    
+    XSRETURN(argvi);
+  fail:
+    
+    SWIG_croak_null();
+  }
+}
+
+
+XS(_wrap_abac_context_load_id_file) {
+  {
+    abac_context_t *arg1 = (abac_context_t *) 0 ;
+    char *arg2 = (char *) 0 ;
+    void *argp1 = 0 ;
+    int res1 = 0 ;
+    int res2 ;
+    char *buf2 = 0 ;
+    int alloc2 = 0 ;
+    int argvi = 0;
+    int result;
+    dXSARGS;
+    
+    if ((items < 2) || (items > 2)) {
+      SWIG_croak("Usage: abac_context_load_id_file(ctx,filename);");
+    }
+    res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p__abac_context_t, 0 |  0 );
+    if (!SWIG_IsOK(res1)) {
+      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "abac_context_load_id_file" "', argument " "1"" of type '" "abac_context_t *""'"); 
+    }
+    arg1 = reinterpret_cast< abac_context_t * >(argp1);
+    res2 = SWIG_AsCharPtrAndSize(ST(1), &buf2, NULL, &alloc2);
+    if (!SWIG_IsOK(res2)) {
+      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "abac_context_load_id_file" "', argument " "2"" of type '" "char *""'");
+    }
+    arg2 = reinterpret_cast< char * >(buf2);
+    {
+      try {
+        result = (int)abac_context_load_id_file(arg1,arg2);
+      }
+      catch (std::invalid_argument) {
+        croak("std::invalid_argument");
+      }
+      catch (std::logic_error) {
+        croak("std::logic_error");
+      }
+    }
+    ST(argvi) = SWIG_From_int  SWIG_PERL_CALL_ARGS_1(static_cast< int >(result)); argvi++ ;
+    
+    if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
+    XSRETURN(argvi);
+  fail:
+    
+    if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
+    SWIG_croak_null();
+  }
+}
+
+
+XS(_wrap_abac_context_load_id_chunk) {
+  {
+    abac_context_t *arg1 = (abac_context_t *) 0 ;
+    abac_chunk_t arg2 ;
+    void *argp1 = 0 ;
+    int res1 = 0 ;
+    int argvi = 0;
+    int result;
+    dXSARGS;
+    
+    if ((items < 2) || (items > 2)) {
+      SWIG_croak("Usage: abac_context_load_id_chunk(ctx,cert);");
+    }
+    res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p__abac_context_t, 0 |  0 );
+    if (!SWIG_IsOK(res1)) {
+      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "abac_context_load_id_chunk" "', argument " "1"" of type '" "abac_context_t *""'"); 
+    }
+    arg1 = reinterpret_cast< abac_context_t * >(argp1);
+    {
+      STRLEN len;
+      (&arg2)->ptr = (unsigned char *)SvPV(ST(1), len);
+      (&arg2)->len = len;
+    }
+    {
+      try {
+        result = (int)abac_context_load_id_chunk(arg1,arg2);
+      }
+      catch (std::invalid_argument) {
+        croak("std::invalid_argument");
+      }
+      catch (std::logic_error) {
+        croak("std::logic_error");
+      }
+    }
+    ST(argvi) = SWIG_From_int  SWIG_PERL_CALL_ARGS_1(static_cast< int >(result)); argvi++ ;
+    
+    XSRETURN(argvi);
+  fail:
+    
+    SWIG_croak_null();
+  }
+}
+
+
+XS(_wrap_abac_context_load_id_id) {
+  {
+    abac_context_t *arg1 = (abac_context_t *) 0 ;
+    abac_id_t *arg2 = (abac_id_t *) 0 ;
+    void *argp1 = 0 ;
+    int res1 = 0 ;
+    void *argp2 = 0 ;
+    int res2 = 0 ;
+    int argvi = 0;
+    int result;
+    dXSARGS;
+    
+    if ((items < 2) || (items > 2)) {
+      SWIG_croak("Usage: abac_context_load_id_id(ctx,cert);");
+    }
+    res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p__abac_context_t, 0 |  0 );
+    if (!SWIG_IsOK(res1)) {
+      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "abac_context_load_id_id" "', argument " "1"" of type '" "abac_context_t *""'"); 
+    }
+    arg1 = reinterpret_cast< abac_context_t * >(argp1);
+    res2 = SWIG_ConvertPtr(ST(1), &argp2,SWIGTYPE_p__abac_id_t, 0 |  0 );
+    if (!SWIG_IsOK(res2)) {
+      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "abac_context_load_id_id" "', argument " "2"" of type '" "abac_id_t *""'"); 
+    }
+    arg2 = reinterpret_cast< abac_id_t * >(argp2);
+    {
+      try {
+        result = (int)abac_context_load_id_id(arg1,arg2);
+      }
+      catch (std::invalid_argument) {
+        croak("std::invalid_argument");
+      }
+      catch (std::logic_error) {
+        croak("std::logic_error");
+      }
+    }
+    ST(argvi) = SWIG_From_int  SWIG_PERL_CALL_ARGS_1(static_cast< int >(result)); argvi++ ;
+    
+    
+    XSRETURN(argvi);
+  fail:
+    
+    
+    SWIG_croak_null();
+  }
+}
+
+
+XS(_wrap_abac_context_load_attribute_file) {
+  {
+    abac_context_t *arg1 = (abac_context_t *) 0 ;
+    char *arg2 = (char *) 0 ;
+    void *argp1 = 0 ;
+    int res1 = 0 ;
+    int res2 ;
+    char *buf2 = 0 ;
+    int alloc2 = 0 ;
+    int argvi = 0;
+    int result;
+    dXSARGS;
+    
+    if ((items < 2) || (items > 2)) {
+      SWIG_croak("Usage: abac_context_load_attribute_file(ctx,filename);");
+    }
+    res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p__abac_context_t, 0 |  0 );
+    if (!SWIG_IsOK(res1)) {
+      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "abac_context_load_attribute_file" "', argument " "1"" of type '" "abac_context_t *""'"); 
+    }
+    arg1 = reinterpret_cast< abac_context_t * >(argp1);
+    res2 = SWIG_AsCharPtrAndSize(ST(1), &buf2, NULL, &alloc2);
+    if (!SWIG_IsOK(res2)) {
+      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "abac_context_load_attribute_file" "', argument " "2"" of type '" "char *""'");
+    }
+    arg2 = reinterpret_cast< char * >(buf2);
+    {
+      try {
+        result = (int)abac_context_load_attribute_file(arg1,arg2);
+      }
+      catch (std::invalid_argument) {
+        croak("std::invalid_argument");
+      }
+      catch (std::logic_error) {
+        croak("std::logic_error");
+      }
+    }
+    ST(argvi) = SWIG_From_int  SWIG_PERL_CALL_ARGS_1(static_cast< int >(result)); argvi++ ;
+    
+    if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
+    XSRETURN(argvi);
+  fail:
+    
+    if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
+    SWIG_croak_null();
+  }
+}
+
+
+XS(_wrap_abac_context_load_attribute_chunk) {
+  {
+    abac_context_t *arg1 = (abac_context_t *) 0 ;
+    abac_chunk_t arg2 ;
+    void *argp1 = 0 ;
+    int res1 = 0 ;
+    int argvi = 0;
+    int result;
+    dXSARGS;
+    
+    if ((items < 2) || (items > 2)) {
+      SWIG_croak("Usage: abac_context_load_attribute_chunk(ctx,cert);");
+    }
+    res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p__abac_context_t, 0 |  0 );
+    if (!SWIG_IsOK(res1)) {
+      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "abac_context_load_attribute_chunk" "', argument " "1"" of type '" "abac_context_t *""'"); 
+    }
+    arg1 = reinterpret_cast< abac_context_t * >(argp1);
+    {
+      STRLEN len;
+      (&arg2)->ptr = (unsigned char *)SvPV(ST(1), len);
+      (&arg2)->len = len;
+    }
+    {
+      try {
+        result = (int)abac_context_load_attribute_chunk(arg1,arg2);
+      }
+      catch (std::invalid_argument) {
+        croak("std::invalid_argument");
+      }
+      catch (std::logic_error) {
+        croak("std::logic_error");
+      }
+    }
+    ST(argvi) = SWIG_From_int  SWIG_PERL_CALL_ARGS_1(static_cast< int >(result)); argvi++ ;
+    
+    XSRETURN(argvi);
+  fail:
+    
+    SWIG_croak_null();
+  }
+}
+
+
+XS(_wrap_abac_context_load_directory) {
+  {
+    abac_context_t *arg1 = (abac_context_t *) 0 ;
+    char *arg2 = (char *) 0 ;
+    void *argp1 = 0 ;
+    int res1 = 0 ;
+    int res2 ;
+    char *buf2 = 0 ;
+    int alloc2 = 0 ;
+    int argvi = 0;
+    dXSARGS;
+    
+    if ((items < 2) || (items > 2)) {
+      SWIG_croak("Usage: abac_context_load_directory(ctx,path);");
+    }
+    res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p__abac_context_t, 0 |  0 );
+    if (!SWIG_IsOK(res1)) {
+      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "abac_context_load_directory" "', argument " "1"" of type '" "abac_context_t *""'"); 
+    }
+    arg1 = reinterpret_cast< abac_context_t * >(argp1);
+    res2 = SWIG_AsCharPtrAndSize(ST(1), &buf2, NULL, &alloc2);
+    if (!SWIG_IsOK(res2)) {
+      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "abac_context_load_directory" "', argument " "2"" of type '" "char *""'");
+    }
+    arg2 = reinterpret_cast< char * >(buf2);
+    {
+      try {
+        abac_context_load_directory(arg1,arg2);
+      }
+      catch (std::invalid_argument) {
+        croak("std::invalid_argument");
+      }
+      catch (std::logic_error) {
+        croak("std::logic_error");
+      }
+    }
+    ST(argvi) = sv_newmortal();
+    
+    if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
+    XSRETURN(argvi);
+  fail:
+    
+    if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
+    SWIG_croak_null();
+  }
+}
+
+
+XS(_wrap_abac_context_query) {
+  {
+    abac_context_t *arg1 = (abac_context_t *) 0 ;
+    char *arg2 = (char *) 0 ;
+    char *arg3 = (char *) 0 ;
+    int *arg4 = (int *) 0 ;
+    void *argp1 = 0 ;
+    int res1 = 0 ;
+    int res2 ;
+    char *buf2 = 0 ;
+    int alloc2 = 0 ;
+    int res3 ;
+    char *buf3 = 0 ;
+    int alloc3 = 0 ;
+    void *argp4 = 0 ;
+    int res4 = 0 ;
+    int argvi = 0;
+    abac_credential_t **result = 0 ;
+    dXSARGS;
+    
+    if ((items < 4) || (items > 4)) {
+      SWIG_croak("Usage: abac_context_query(ctx,role,principal,success);");
+    }
+    res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p__abac_context_t, 0 |  0 );
+    if (!SWIG_IsOK(res1)) {
+      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "abac_context_query" "', argument " "1"" of type '" "abac_context_t *""'"); 
+    }
+    arg1 = reinterpret_cast< abac_context_t * >(argp1);
+    res2 = SWIG_AsCharPtrAndSize(ST(1), &buf2, NULL, &alloc2);
+    if (!SWIG_IsOK(res2)) {
+      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "abac_context_query" "', argument " "2"" of type '" "char *""'");
+    }
+    arg2 = reinterpret_cast< char * >(buf2);
+    res3 = SWIG_AsCharPtrAndSize(ST(2), &buf3, NULL, &alloc3);
+    if (!SWIG_IsOK(res3)) {
+      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "abac_context_query" "', argument " "3"" of type '" "char *""'");
+    }
+    arg3 = reinterpret_cast< char * >(buf3);
+    res4 = SWIG_ConvertPtr(ST(3), &argp4,SWIGTYPE_p_int, 0 |  0 );
+    if (!SWIG_IsOK(res4)) {
+      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "abac_context_query" "', argument " "4"" of type '" "int *""'"); 
+    }
+    arg4 = reinterpret_cast< int * >(argp4);
+    {
+      try {
+        result = (abac_credential_t **)abac_context_query(arg1,arg2,arg3,arg4);
+      }
+      catch (std::invalid_argument) {
+        croak("std::invalid_argument");
+      }
+      catch (std::logic_error) {
+        croak("std::logic_error");
+      }
+    }
+    ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_p__abac_credential_t, 0 | 0); argvi++ ;
+    
+    if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
+    if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
+    
+    XSRETURN(argvi);
+  fail:
+    
+    if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
+    if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
+    
+    SWIG_croak_null();
+  }
+}
+
+
+XS(_wrap_abac_context_credentials) {
+  {
+    abac_context_t *arg1 = (abac_context_t *) 0 ;
+    void *argp1 = 0 ;
+    int res1 = 0 ;
+    int argvi = 0;
+    abac_credential_t **result = 0 ;
+    dXSARGS;
+    
+    if ((items < 1) || (items > 1)) {
+      SWIG_croak("Usage: abac_context_credentials(ctx);");
+    }
+    res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p__abac_context_t, 0 |  0 );
+    if (!SWIG_IsOK(res1)) {
+      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "abac_context_credentials" "', argument " "1"" of type '" "abac_context_t *""'"); 
+    }
+    arg1 = reinterpret_cast< abac_context_t * >(argp1);
+    {
+      try {
+        result = (abac_credential_t **)abac_context_credentials(arg1);
+      }
+      catch (std::invalid_argument) {
+        croak("std::invalid_argument");
+      }
+      catch (std::logic_error) {
+        croak("std::logic_error");
+      }
+    }
+    ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_p__abac_credential_t, 0 | 0); argvi++ ;
+    
+    XSRETURN(argvi);
+  fail:
+    
+    SWIG_croak_null();
+  }
+}
+
+
+XS(_wrap_abac_context_principals) {
+  {
+    abac_context_t *arg1 = (abac_context_t *) 0 ;
+    void *argp1 = 0 ;
+    int res1 = 0 ;
+    int argvi = 0;
+    abac_id_cert_t **result = 0 ;
+    dXSARGS;
+    
+    if ((items < 1) || (items > 1)) {
+      SWIG_croak("Usage: abac_context_principals(ctx);");
+    }
+    res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p__abac_context_t, 0 |  0 );
+    if (!SWIG_IsOK(res1)) {
+      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "abac_context_principals" "', argument " "1"" of type '" "abac_context_t *""'"); 
+    }
+    arg1 = reinterpret_cast< abac_context_t * >(argp1);
+    {
+      try {
+        result = (abac_id_cert_t **)abac_context_principals(arg1);
+      }
+      catch (std::invalid_argument) {
+        croak("std::invalid_argument");
+      }
+      catch (std::logic_error) {
+        croak("std::logic_error");
+      }
+    }
+    ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_p__abac_id_cert_t, 0 | 0); argvi++ ;
+    
+    XSRETURN(argvi);
+  fail:
+    
+    SWIG_croak_null();
+  }
+}
+
+
+XS(_wrap_abac_context_id_credentials_free) {
+  {
+    abac_id_cert_t **arg1 = (abac_id_cert_t **) 0 ;
+    void *argp1 = 0 ;
+    int res1 = 0 ;
+    int argvi = 0;
+    dXSARGS;
+    
+    if ((items < 1) || (items > 1)) {
+      SWIG_croak("Usage: abac_context_id_credentials_free(abac_id_cert_t **);");
+    }
+    res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_p__abac_id_cert_t, 0 |  0 );
+    if (!SWIG_IsOK(res1)) {
+      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "abac_context_id_credentials_free" "', argument " "1"" of type '" "abac_id_cert_t **""'"); 
+    }
+    arg1 = reinterpret_cast< abac_id_cert_t ** >(argp1);
+    {
+      try {
+        abac_context_id_credentials_free(arg1);
+      }
+      catch (std::invalid_argument) {
+        croak("std::invalid_argument");
+      }
+      catch (std::logic_error) {
+        croak("std::logic_error");
+      }
+    }
+    ST(argvi) = sv_newmortal();
+    
+    XSRETURN(argvi);
+  fail:
+    
+    SWIG_croak_null();
+  }
+}
+
+
+XS(_wrap_abac_context_credentials_free) {
+  {
+    abac_credential_t **arg1 = (abac_credential_t **) 0 ;
+    void *argp1 = 0 ;
+    int res1 = 0 ;
+    int argvi = 0;
+    dXSARGS;
+    
+    if ((items < 1) || (items > 1)) {
+      SWIG_croak("Usage: abac_context_credentials_free(credentials);");
+    }
+    res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_p__abac_credential_t, 0 |  0 );
+    if (!SWIG_IsOK(res1)) {
+      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "abac_context_credentials_free" "', argument " "1"" of type '" "abac_credential_t **""'"); 
+    }
+    arg1 = reinterpret_cast< abac_credential_t ** >(argp1);
+    {
+      try {
+        abac_context_credentials_free(arg1);
+      }
+      catch (std::invalid_argument) {
+        croak("std::invalid_argument");
+      }
+      catch (std::logic_error) {
+        croak("std::logic_error");
+      }
+    }
+    ST(argvi) = sv_newmortal();
+    
+    XSRETURN(argvi);
+  fail:
+    
+    SWIG_croak_null();
+  }
+}
+
+
+XS(_wrap_abac_context_set_nickname) {
+  {
+    abac_context_t *arg1 = (abac_context_t *) 0 ;
+    char *arg2 = (char *) 0 ;
+    char *arg3 = (char *) 0 ;
+    void *argp1 = 0 ;
+    int res1 = 0 ;
+    int res2 ;
+    char *buf2 = 0 ;
+    int alloc2 = 0 ;
+    int res3 ;
+    char *buf3 = 0 ;
+    int alloc3 = 0 ;
+    int argvi = 0;
+    int result;
+    dXSARGS;
+    
+    if ((items < 3) || (items > 3)) {
+      SWIG_croak("Usage: abac_context_set_nickname(ctxt,key,nick);");
+    }
+    res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p__abac_context_t, 0 |  0 );
+    if (!SWIG_IsOK(res1)) {
+      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "abac_context_set_nickname" "', argument " "1"" of type '" "abac_context_t *""'"); 
+    }
+    arg1 = reinterpret_cast< abac_context_t * >(argp1);
+    res2 = SWIG_AsCharPtrAndSize(ST(1), &buf2, NULL, &alloc2);
+    if (!SWIG_IsOK(res2)) {
+      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "abac_context_set_nickname" "', argument " "2"" of type '" "char *""'");
+    }
+    arg2 = reinterpret_cast< char * >(buf2);
+    res3 = SWIG_AsCharPtrAndSize(ST(2), &buf3, NULL, &alloc3);
+    if (!SWIG_IsOK(res3)) {
+      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "abac_context_set_nickname" "', argument " "3"" of type '" "char *""'");
+    }
+    arg3 = reinterpret_cast< char * >(buf3);
+    {
+      try {
+        result = (int)abac_context_set_nickname(arg1,arg2,arg3);
+      }
+      catch (std::invalid_argument) {
+        croak("std::invalid_argument");
+      }
+      catch (std::logic_error) {
+        croak("std::logic_error");
+      }
+    }
+    ST(argvi) = SWIG_From_int  SWIG_PERL_CALL_ARGS_1(static_cast< int >(result)); argvi++ ;
+    
+    if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
+    if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
+    XSRETURN(argvi);
+  fail:
+    
+    if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
+    if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
+    SWIG_croak_null();
+  }
+}
+
+
+XS(_wrap_abac_context_expand_key) {
+  {
+    abac_context_t *arg1 = (abac_context_t *) 0 ;
+    char *arg2 = (char *) 0 ;
+    void *argp1 = 0 ;
+    int res1 = 0 ;
+    int res2 ;
+    char *buf2 = 0 ;
+    int alloc2 = 0 ;
+    int argvi = 0;
+    char *result = 0 ;
+    dXSARGS;
+    
+    if ((items < 2) || (items > 2)) {
+      SWIG_croak("Usage: abac_context_expand_key(ctxt,s);");
+    }
+    res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p__abac_context_t, 0 |  0 );
+    if (!SWIG_IsOK(res1)) {
+      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "abac_context_expand_key" "', argument " "1"" of type '" "abac_context_t *""'"); 
+    }
+    arg1 = reinterpret_cast< abac_context_t * >(argp1);
+    res2 = SWIG_AsCharPtrAndSize(ST(1), &buf2, NULL, &alloc2);
+    if (!SWIG_IsOK(res2)) {
+      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "abac_context_expand_key" "', argument " "2"" of type '" "char *""'");
+    }
+    arg2 = reinterpret_cast< char * >(buf2);
+    {
+      try {
+        result = (char *)abac_context_expand_key(arg1,arg2);
+      }
+      catch (std::invalid_argument) {
+        croak("std::invalid_argument");
+      }
+      catch (std::logic_error) {
+        croak("std::logic_error");
+      }
+    }
+    ST(argvi) = SWIG_FromCharPtr((const char *)result); argvi++ ;
+    
+    if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
+    XSRETURN(argvi);
+  fail:
+    
+    if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
+    SWIG_croak_null();
+  }
+}
+
+
+XS(_wrap_abac_context_expand_nickname) {
+  {
+    abac_context_t *arg1 = (abac_context_t *) 0 ;
+    char *arg2 = (char *) 0 ;
+    void *argp1 = 0 ;
+    int res1 = 0 ;
+    int res2 ;
+    char *buf2 = 0 ;
+    int alloc2 = 0 ;
+    int argvi = 0;
+    char *result = 0 ;
+    dXSARGS;
+    
+    if ((items < 2) || (items > 2)) {
+      SWIG_croak("Usage: abac_context_expand_nickname(ctxt,s);");
+    }
+    res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p__abac_context_t, 0 |  0 );
+    if (!SWIG_IsOK(res1)) {
+      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "abac_context_expand_nickname" "', argument " "1"" of type '" "abac_context_t *""'"); 
+    }
+    arg1 = reinterpret_cast< abac_context_t * >(argp1);
+    res2 = SWIG_AsCharPtrAndSize(ST(1), &buf2, NULL, &alloc2);
+    if (!SWIG_IsOK(res2)) {
+      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "abac_context_expand_nickname" "', argument " "2"" of type '" "char *""'");
+    }
+    arg2 = reinterpret_cast< char * >(buf2);
+    {
+      try {
+        result = (char *)abac_context_expand_nickname(arg1,arg2);
+      }
+      catch (std::invalid_argument) {
+        croak("std::invalid_argument");
+      }
+      catch (std::logic_error) {
+        croak("std::logic_error");
+      }
+    }
+    ST(argvi) = SWIG_FromCharPtr((const char *)result); argvi++ ;
+    
+    if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
+    XSRETURN(argvi);
+  fail:
+    
+    if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
+    SWIG_croak_null();
+  }
+}
+
+
+XS(_wrap_abac_context_get_keyid_map) {
+  {
+    abac_context_t *arg1 = (abac_context_t *) 0 ;
+    void *argp1 = 0 ;
+    int res1 = 0 ;
+    int argvi = 0;
+    abac_keyid_map_t *result = 0 ;
+    dXSARGS;
+    
+    if ((items < 1) || (items > 1)) {
+      SWIG_croak("Usage: abac_context_get_keyid_map(ctxt);");
+    }
+    res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p__abac_context_t, 0 |  0 );
+    if (!SWIG_IsOK(res1)) {
+      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "abac_context_get_keyid_map" "', argument " "1"" of type '" "abac_context_t *""'"); 
+    }
+    arg1 = reinterpret_cast< abac_context_t * >(argp1);
+    {
+      try {
+        result = (abac_keyid_map_t *)abac_context_get_keyid_map(arg1);
+      }
+      catch (std::invalid_argument) {
+        croak("std::invalid_argument");
+      }
+      catch (std::logic_error) {
+        croak("std::logic_error");
+      }
+    }
+    ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_abac_keyid_map_t, 0 | 0); argvi++ ;
+    
+    XSRETURN(argvi);
+  fail:
+    
+    SWIG_croak_null();
+  }
+}
+
+
+XS(_wrap_abac_credential_head) {
+  {
+    abac_credential_t *arg1 = (abac_credential_t *) 0 ;
+    void *argp1 = 0 ;
+    int res1 = 0 ;
+    int argvi = 0;
+    abac_role_t *result = 0 ;
+    dXSARGS;
+    
+    if ((items < 1) || (items > 1)) {
+      SWIG_croak("Usage: abac_credential_head(cred);");
+    }
+    res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p__abac_credential_t, 0 |  0 );
+    if (!SWIG_IsOK(res1)) {
+      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "abac_credential_head" "', argument " "1"" of type '" "abac_credential_t *""'"); 
+    }
+    arg1 = reinterpret_cast< abac_credential_t * >(argp1);
+    {
+      try {
+        result = (abac_role_t *)abac_credential_head(arg1);
+      }
+      catch (std::invalid_argument) {
+        croak("std::invalid_argument");
+      }
+      catch (std::logic_error) {
+        croak("std::logic_error");
+      }
+    }
+    ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__abac_role_t, 0 | 0); argvi++ ;
+    
+    XSRETURN(argvi);
+  fail:
+    
+    SWIG_croak_null();
+  }
+}
+
+
+XS(_wrap_abac_credential_tail) {
+  {
+    abac_credential_t *arg1 = (abac_credential_t *) 0 ;
+    void *argp1 = 0 ;
+    int res1 = 0 ;
+    int argvi = 0;
+    abac_role_t *result = 0 ;
+    dXSARGS;
+    
+    if ((items < 1) || (items > 1)) {
+      SWIG_croak("Usage: abac_credential_tail(cred);");
+    }
+    res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p__abac_credential_t, 0 |  0 );
+    if (!SWIG_IsOK(res1)) {
+      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "abac_credential_tail" "', argument " "1"" of type '" "abac_credential_t *""'"); 
+    }
+    arg1 = reinterpret_cast< abac_credential_t * >(argp1);
+    {
+      try {
+        result = (abac_role_t *)abac_credential_tail(arg1);
+      }
+      catch (std::invalid_argument) {
+        croak("std::invalid_argument");
+      }
+      catch (std::logic_error) {
+        croak("std::logic_error");
+      }
+    }
+    ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__abac_role_t, 0 | 0); argvi++ ;
+    
+    XSRETURN(argvi);
+  fail:
+    
+    SWIG_croak_null();
+  }
+}
+
+
+XS(_wrap_abac_credential_attribute_cert) {
+  {
+    abac_credential_t *arg1 = (abac_credential_t *) 0 ;
+    void *argp1 = 0 ;
+    int res1 = 0 ;
+    int argvi = 0;
+    abac_chunk_t result;
+    dXSARGS;
+    
+    if ((items < 1) || (items > 1)) {
+      SWIG_croak("Usage: abac_credential_attribute_cert(cred);");
+    }
+    res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p__abac_credential_t, 0 |  0 );
+    if (!SWIG_IsOK(res1)) {
+      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "abac_credential_attribute_cert" "', argument " "1"" of type '" "abac_credential_t *""'"); 
+    }
+    arg1 = reinterpret_cast< abac_credential_t * >(argp1);
+    {
+      try {
+        result = abac_credential_attribute_cert(arg1);
+      }
+      catch (std::invalid_argument) {
+        croak("std::invalid_argument");
+      }
+      catch (std::logic_error) {
+        croak("std::logic_error");
+      }
+    }
+    {
+      ST(argvi) = newSVpvn(
+        (const char *)(&result)->ptr,
+        (&result)->len
+        );
+      ++argvi;
+    }
+    
+    XSRETURN(argvi);
+  fail:
+    
+    SWIG_croak_null();
+  }
+}
+
+
+XS(_wrap_abac_credential_issuer_cert) {
+  {
+    abac_credential_t *arg1 = (abac_credential_t *) 0 ;
+    void *argp1 = 0 ;
+    int res1 = 0 ;
+    int argvi = 0;
+    abac_chunk_t result;
+    dXSARGS;
+    
+    if ((items < 1) || (items > 1)) {
+      SWIG_croak("Usage: abac_credential_issuer_cert(cred);");
+    }
+    res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p__abac_credential_t, 0 |  0 );
+    if (!SWIG_IsOK(res1)) {
+      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "abac_credential_issuer_cert" "', argument " "1"" of type '" "abac_credential_t *""'"); 
+    }
+    arg1 = reinterpret_cast< abac_credential_t * >(argp1);
+    {
+      try {
+        result = abac_credential_issuer_cert(arg1);
+      }
+      catch (std::invalid_argument) {
+        croak("std::invalid_argument");
+      }
+      catch (std::logic_error) {
+        croak("std::logic_error");
+      }
+    }
+    {
+      ST(argvi) = newSVpvn(
+        (const char *)(&result)->ptr,
+        (&result)->len
+        );
+      ++argvi;
+    }
+    
+    XSRETURN(argvi);
+  fail:
+    
+    SWIG_croak_null();
+  }
+}
+
+
+XS(_wrap_abac_credential_dup) {
+  {
+    abac_credential_t *arg1 = (abac_credential_t *) 0 ;
+    void *argp1 = 0 ;
+    int res1 = 0 ;
+    int argvi = 0;
+    abac_credential_t *result = 0 ;
+    dXSARGS;
+    
+    if ((items < 1) || (items > 1)) {
+      SWIG_croak("Usage: abac_credential_dup(cred);");
+    }
+    res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p__abac_credential_t, 0 |  0 );
+    if (!SWIG_IsOK(res1)) {
+      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "abac_credential_dup" "', argument " "1"" of type '" "abac_credential_t *""'"); 
+    }
+    arg1 = reinterpret_cast< abac_credential_t * >(argp1);
+    {
+      try {
+        result = (abac_credential_t *)abac_credential_dup(arg1);
+      }
+      catch (std::invalid_argument) {
+        croak("std::invalid_argument");
+      }
+      catch (std::logic_error) {
+        croak("std::logic_error");
+      }
+    }
+    ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__abac_credential_t, 0 | 0); argvi++ ;
+    
+    XSRETURN(argvi);
+  fail:
+    
+    SWIG_croak_null();
+  }
+}
+
+
+XS(_wrap_abac_credential_free) {
+  {
+    abac_credential_t *arg1 = (abac_credential_t *) 0 ;
+    void *argp1 = 0 ;
+    int res1 = 0 ;
+    int argvi = 0;
+    dXSARGS;
+    
+    if ((items < 1) || (items > 1)) {
+      SWIG_croak("Usage: abac_credential_free(cred);");
+    }
+    res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p__abac_credential_t, 0 |  0 );
+    if (!SWIG_IsOK(res1)) {
+      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "abac_credential_free" "', argument " "1"" of type '" "abac_credential_t *""'"); 
+    }
+    arg1 = reinterpret_cast< abac_credential_t * >(argp1);
+    {
+      try {
+        abac_credential_free(arg1);
+      }
+      catch (std::invalid_argument) {
+        croak("std::invalid_argument");
+      }
+      catch (std::logic_error) {
+        croak("std::logic_error");
+      }
+    }
+    ST(argvi) = sv_newmortal();
+    
+    XSRETURN(argvi);
+  fail:
+    
+    SWIG_croak_null();
+  }
+}
+
+
+XS(_wrap_abac_id_cert_keyid) {
+  {
+    abac_id_cert_t *arg1 = (abac_id_cert_t *) 0 ;
+    void *argp1 = 0 ;
+    int res1 = 0 ;
+    int argvi = 0;
+    char *result = 0 ;
+    dXSARGS;
+    
+    if ((items < 1) || (items > 1)) {
+      SWIG_croak("Usage: abac_id_cert_keyid(abac_id_cert_t *);");
+    }
+    res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p__abac_id_cert_t, 0 |  0 );
+    if (!SWIG_IsOK(res1)) {
+      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "abac_id_cert_keyid" "', argument " "1"" of type '" "abac_id_cert_t *""'"); 
+    }
+    arg1 = reinterpret_cast< abac_id_cert_t * >(argp1);
+    {
+      try {
+        result = (char *)abac_id_cert_keyid(arg1);
+      }
+      catch (std::invalid_argument) {
+        croak("std::invalid_argument");
+      }
+      catch (std::logic_error) {
+        croak("std::logic_error");
+      }
+    }
+    ST(argvi) = SWIG_FromCharPtr((const char *)result); argvi++ ;
+    
+    XSRETURN(argvi);
+  fail:
+    
+    SWIG_croak_null();
+  }
+}
+
+
+XS(_wrap_abac_id_cert_cn) {
+  {
+    abac_id_cert_t *arg1 = (abac_id_cert_t *) 0 ;
+    void *argp1 = 0 ;
+    int res1 = 0 ;
+    int argvi = 0;
+    char *result = 0 ;
+    dXSARGS;
+    
+    if ((items < 1) || (items > 1)) {
+      SWIG_croak("Usage: abac_id_cert_cn(abac_id_cert_t *);");
+    }
+    res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p__abac_id_cert_t, 0 |  0 );
+    if (!SWIG_IsOK(res1)) {
+      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "abac_id_cert_cn" "', argument " "1"" of type '" "abac_id_cert_t *""'"); 
+    }
+    arg1 = reinterpret_cast< abac_id_cert_t * >(argp1);
+    {
+      try {
+        result = (char *)abac_id_cert_cn(arg1);
+      }
+      catch (std::invalid_argument) {
+        croak("std::invalid_argument");
+      }
+      catch (std::logic_error) {
+        croak("std::logic_error");
+      }
+    }
+    ST(argvi) = SWIG_FromCharPtr((const char *)result); argvi++ ;
+    
+    XSRETURN(argvi);
+  fail:
+    
+    SWIG_croak_null();
+  }
+}
+
+
+XS(_wrap_abac_role_principal_new) {
+  {
+    char *arg1 = (char *) 0 ;
+    int res1 ;
+    char *buf1 = 0 ;
+    int alloc1 = 0 ;
+    int argvi = 0;
+    abac_role_t *result = 0 ;
+    dXSARGS;
+    
+    if ((items < 1) || (items > 1)) {
+      SWIG_croak("Usage: abac_role_principal_new(principal);");
+    }
+    res1 = SWIG_AsCharPtrAndSize(ST(0), &buf1, NULL, &alloc1);
+    if (!SWIG_IsOK(res1)) {
+      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "abac_role_principal_new" "', argument " "1"" of type '" "char *""'");
+    }
+    arg1 = reinterpret_cast< char * >(buf1);
+    {
+      try {
+        result = (abac_role_t *)abac_role_principal_new(arg1);
+      }
+      catch (std::invalid_argument) {
+        croak("std::invalid_argument");
+      }
+      catch (std::logic_error) {
+        croak("std::logic_error");
+      }
+    }
+    ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__abac_role_t, 0 | 0); argvi++ ;
+    if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
+    XSRETURN(argvi);
+  fail:
+    if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
+    SWIG_croak_null();
+  }
+}
+
+
+XS(_wrap_abac_role_role_new) {
+  {
+    char *arg1 = (char *) 0 ;
+    char *arg2 = (char *) 0 ;
+    int res1 ;
+    char *buf1 = 0 ;
+    int alloc1 = 0 ;
+    int res2 ;
+    char *buf2 = 0 ;
+    int alloc2 = 0 ;
+    int argvi = 0;
+    abac_role_t *result = 0 ;
+    dXSARGS;
+    
+    if ((items < 2) || (items > 2)) {
+      SWIG_croak("Usage: abac_role_role_new(principal,abac_role_name);");
+    }
+    res1 = SWIG_AsCharPtrAndSize(ST(0), &buf1, NULL, &alloc1);
+    if (!SWIG_IsOK(res1)) {
+      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "abac_role_role_new" "', argument " "1"" of type '" "char *""'");
+    }
+    arg1 = reinterpret_cast< char * >(buf1);
+    res2 = SWIG_AsCharPtrAndSize(ST(1), &buf2, NULL, &alloc2);
+    if (!SWIG_IsOK(res2)) {
+      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "abac_role_role_new" "', argument " "2"" of type '" "char *""'");
+    }
+    arg2 = reinterpret_cast< char * >(buf2);
+    {
+      try {
+        result = (abac_role_t *)abac_role_role_new(arg1,arg2);
+      }
+      catch (std::invalid_argument) {
+        croak("std::invalid_argument");
+      }
+      catch (std::logic_error) {
+        croak("std::logic_error");
+      }
+    }
+    ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__abac_role_t, 0 | 0); argvi++ ;
+    if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
+    if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
+    XSRETURN(argvi);
+  fail:
+    if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
+    if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
+    SWIG_croak_null();
+  }
+}
+
+
+XS(_wrap_abac_role_linking_new) {
+  {
+    char *arg1 = (char *) 0 ;
+    char *arg2 = (char *) 0 ;
+    char *arg3 = (char *) 0 ;
+    int res1 ;
+    char *buf1 = 0 ;
+    int alloc1 = 0 ;
+    int res2 ;
+    char *buf2 = 0 ;
+    int alloc2 = 0 ;
+    int res3 ;
+    char *buf3 = 0 ;
+    int alloc3 = 0 ;
+    int argvi = 0;
+    abac_role_t *result = 0 ;
+    dXSARGS;
+    
+    if ((items < 3) || (items > 3)) {
+      SWIG_croak("Usage: abac_role_linking_new(principal,linked_role,abac_role_name);");
+    }
+    res1 = SWIG_AsCharPtrAndSize(ST(0), &buf1, NULL, &alloc1);
+    if (!SWIG_IsOK(res1)) {
+      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "abac_role_linking_new" "', argument " "1"" of type '" "char *""'");
+    }
+    arg1 = reinterpret_cast< char * >(buf1);
+    res2 = SWIG_AsCharPtrAndSize(ST(1), &buf2, NULL, &alloc2);
+    if (!SWIG_IsOK(res2)) {
+      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "abac_role_linking_new" "', argument " "2"" of type '" "char *""'");
+    }
+    arg2 = reinterpret_cast< char * >(buf2);
+    res3 = SWIG_AsCharPtrAndSize(ST(2), &buf3, NULL, &alloc3);
+    if (!SWIG_IsOK(res3)) {
+      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "abac_role_linking_new" "', argument " "3"" of type '" "char *""'");
+    }
+    arg3 = reinterpret_cast< char * >(buf3);
+    {
+      try {
+        result = (abac_role_t *)abac_role_linking_new(arg1,arg2,arg3);
+      }
+      catch (std::invalid_argument) {
+        croak("std::invalid_argument");
+      }
+      catch (std::logic_error) {
+        croak("std::logic_error");
+      }
+    }
+    ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__abac_role_t, 0 | 0); argvi++ ;
+    if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
+    if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
+    if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
+    XSRETURN(argvi);
+  fail:
+    if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
+    if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
+    if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
+    SWIG_croak_null();
+  }
+}
+
+
+XS(_wrap_abac_role_free) {
+  {
+    abac_role_t *arg1 = (abac_role_t *) 0 ;
+    void *argp1 = 0 ;
+    int res1 = 0 ;
+    int argvi = 0;
+    dXSARGS;
+    
+    if ((items < 1) || (items > 1)) {
+      SWIG_croak("Usage: abac_role_free(role);");
+    }
+    res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p__abac_role_t, 0 |  0 );
+    if (!SWIG_IsOK(res1)) {
+      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "abac_role_free" "', argument " "1"" of type '" "abac_role_t *""'"); 
+    }
+    arg1 = reinterpret_cast< abac_role_t * >(argp1);
+    {
+      try {
+        abac_role_free(arg1);
+      }
+      catch (std::invalid_argument) {
+        croak("std::invalid_argument");
+      }
+      catch (std::logic_error) {
+        croak("std::logic_error");
+      }
+    }
+    ST(argvi) = sv_newmortal();
+    
+    XSRETURN(argvi);
+  fail:
+    
+    SWIG_croak_null();
+  }
+}
+
+
+XS(_wrap_abac_role_from_string) {
+  {
+    char *arg1 = (char *) 0 ;
+    int res1 ;
+    char *buf1 = 0 ;
+    int alloc1 = 0 ;
+    int argvi = 0;
+    abac_role_t *result = 0 ;
+    dXSARGS;
+    
+    if ((items < 1) || (items > 1)) {
+      SWIG_croak("Usage: abac_role_from_string(string);");
+    }
+    res1 = SWIG_AsCharPtrAndSize(ST(0), &buf1, NULL, &alloc1);
+    if (!SWIG_IsOK(res1)) {
+      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "abac_role_from_string" "', argument " "1"" of type '" "char *""'");
+    }
+    arg1 = reinterpret_cast< char * >(buf1);
+    {
+      try {
+        result = (abac_role_t *)abac_role_from_string(arg1);
+      }
+      catch (std::invalid_argument) {
+        croak("std::invalid_argument");
+      }
+      catch (std::logic_error) {
+        croak("std::logic_error");
+      }
+    }
+    ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__abac_role_t, 0 | 0); argvi++ ;
+    if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
+    XSRETURN(argvi);
+  fail:
+    if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
+    SWIG_croak_null();
+  }
+}
+
+
+XS(_wrap_abac_role_dup) {
+  {
+    abac_role_t *arg1 = (abac_role_t *) 0 ;
+    void *argp1 = 0 ;
+    int res1 = 0 ;
+    int argvi = 0;
+    abac_role_t *result = 0 ;
+    dXSARGS;
+    
+    if ((items < 1) || (items > 1)) {
+      SWIG_croak("Usage: abac_role_dup(role);");
+    }
+    res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p__abac_role_t, 0 |  0 );
+    if (!SWIG_IsOK(res1)) {
+      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "abac_role_dup" "', argument " "1"" of type '" "abac_role_t *""'"); 
+    }
+    arg1 = reinterpret_cast< abac_role_t * >(argp1);
+    {
+      try {
+        result = (abac_role_t *)abac_role_dup(arg1);
+      }
+      catch (std::invalid_argument) {
+        croak("std::invalid_argument");
+      }
+      catch (std::logic_error) {
+        croak("std::logic_error");
+      }
+    }
+    ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__abac_role_t, 0 | 0); argvi++ ;
+    
+    XSRETURN(argvi);
+  fail:
+    
+    SWIG_croak_null();
+  }
+}
+
+
+XS(_wrap_abac_role_is_principal) {
+  {
+    abac_role_t *arg1 = (abac_role_t *) 0 ;
+    void *argp1 = 0 ;
+    int res1 = 0 ;
+    int argvi = 0;
+    int result;
+    dXSARGS;
+    
+    if ((items < 1) || (items > 1)) {
+      SWIG_croak("Usage: abac_role_is_principal(role);");
+    }
+    res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p__abac_role_t, 0 |  0 );
+    if (!SWIG_IsOK(res1)) {
+      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "abac_role_is_principal" "', argument " "1"" of type '" "abac_role_t *""'"); 
+    }
+    arg1 = reinterpret_cast< abac_role_t * >(argp1);
+    {
+      try {
+        result = (int)abac_role_is_principal(arg1);
+      }
+      catch (std::invalid_argument) {
+        croak("std::invalid_argument");
+      }
+      catch (std::logic_error) {
+        croak("std::logic_error");
+      }
+    }
+    ST(argvi) = SWIG_From_int  SWIG_PERL_CALL_ARGS_1(static_cast< int >(result)); argvi++ ;
+    
+    XSRETURN(argvi);
+  fail:
+    
+    SWIG_croak_null();
+  }
+}
+
+
+XS(_wrap_abac_role_is_role) {
+  {
+    abac_role_t *arg1 = (abac_role_t *) 0 ;
+    void *argp1 = 0 ;
+    int res1 = 0 ;
+    int argvi = 0;
+    int result;
+    dXSARGS;
+    
+    if ((items < 1) || (items > 1)) {
+      SWIG_croak("Usage: abac_role_is_role(role);");
+    }
+    res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p__abac_role_t, 0 |  0 );
+    if (!SWIG_IsOK(res1)) {
+      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "abac_role_is_role" "', argument " "1"" of type '" "abac_role_t *""'"); 
+    }
+    arg1 = reinterpret_cast< abac_role_t * >(argp1);
+    {
+      try {
+        result = (int)abac_role_is_role(arg1);
+      }
+      catch (std::invalid_argument) {
+        croak("std::invalid_argument");
+      }
+      catch (std::logic_error) {
+        croak("std::logic_error");
+      }
+    }
+    ST(argvi) = SWIG_From_int  SWIG_PERL_CALL_ARGS_1(static_cast< int >(result)); argvi++ ;
+    
+    XSRETURN(argvi);
+  fail:
+    
+    SWIG_croak_null();
+  }
+}
+
+
+XS(_wrap_abac_role_is_linking) {
+  {
+    abac_role_t *arg1 = (abac_role_t *) 0 ;
+    void *argp1 = 0 ;
+    int res1 = 0 ;
+    int argvi = 0;
+    int result;
+    dXSARGS;
+    
+    if ((items < 1) || (items > 1)) {
+      SWIG_croak("Usage: abac_role_is_linking(role);");
+    }
+    res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p__abac_role_t, 0 |  0 );
+    if (!SWIG_IsOK(res1)) {
+      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "abac_role_is_linking" "', argument " "1"" of type '" "abac_role_t *""'"); 
+    }
+    arg1 = reinterpret_cast< abac_role_t * >(argp1);
+    {
+      try {
+        result = (int)abac_role_is_linking(arg1);
+      }
+      catch (std::invalid_argument) {
+        croak("std::invalid_argument");
+      }
+      catch (std::logic_error) {
+        croak("std::logic_error");
+      }
+    }
+    ST(argvi) = SWIG_From_int  SWIG_PERL_CALL_ARGS_1(static_cast< int >(result)); argvi++ ;
+    
+    XSRETURN(argvi);
+  fail:
+    
+    SWIG_croak_null();
+  }
+}
+
+
+XS(_wrap_abac_role_is_intersection) {
+  {
+    abac_role_t *arg1 = (abac_role_t *) 0 ;
+    void *argp1 = 0 ;
+    int res1 = 0 ;
+    int argvi = 0;
+    int result;
+    dXSARGS;
+    
+    if ((items < 1) || (items > 1)) {
+      SWIG_croak("Usage: abac_role_is_intersection(role);");
+    }
+    res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p__abac_role_t, 0 |  0 );
+    if (!SWIG_IsOK(res1)) {
+      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "abac_role_is_intersection" "', argument " "1"" of type '" "abac_role_t *""'"); 
+    }
+    arg1 = reinterpret_cast< abac_role_t * >(argp1);
+    {
+      try {
+        result = (int)abac_role_is_intersection(arg1);
+      }
+      catch (std::invalid_argument) {
+        croak("std::invalid_argument");
+      }
+      catch (std::logic_error) {
+        croak("std::logic_error");
+      }
+    }
+    ST(argvi) = SWIG_From_int  SWIG_PERL_CALL_ARGS_1(static_cast< int >(result)); argvi++ ;
+    
+    XSRETURN(argvi);
+  fail:
+    
+    SWIG_croak_null();
+  }
+}
+
+
+XS(_wrap_abac_role_string) {
+  {
+    abac_role_t *arg1 = (abac_role_t *) 0 ;
+    void *argp1 = 0 ;
+    int res1 = 0 ;
+    int argvi = 0;
+    char *result = 0 ;
+    dXSARGS;
+    
+    if ((items < 1) || (items > 1)) {
+      SWIG_croak("Usage: abac_role_string(role);");
+    }
+    res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p__abac_role_t, 0 |  0 );
+    if (!SWIG_IsOK(res1)) {
+      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "abac_role_string" "', argument " "1"" of type '" "abac_role_t *""'"); 
+    }
+    arg1 = reinterpret_cast< abac_role_t * >(argp1);
+    {
+      try {
+        result = (char *)abac_role_string(arg1);
+      }
+      catch (std::invalid_argument) {
+        croak("std::invalid_argument");
+      }
+      catch (std::logic_error) {
+        croak("std::logic_error");
+      }
+    }
+    ST(argvi) = SWIG_FromCharPtr((const char *)result); argvi++ ;
+    
+    XSRETURN(argvi);
+  fail:
+    
+    SWIG_croak_null();
+  }
+}
+
+
+XS(_wrap_abac_role_short_string) {
+  {
+    abac_role_t *arg1 = (abac_role_t *) 0 ;
+    abac_context_t *arg2 = (abac_context_t *) 0 ;
+    void *argp1 = 0 ;
+    int res1 = 0 ;
+    void *argp2 = 0 ;
+    int res2 = 0 ;
+    int argvi = 0;
+    char *result = 0 ;
+    dXSARGS;
+    
+    if ((items < 2) || (items > 2)) {
+      SWIG_croak("Usage: abac_role_short_string(role,ctxt);");
+    }
+    res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p__abac_role_t, 0 |  0 );
+    if (!SWIG_IsOK(res1)) {
+      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "abac_role_short_string" "', argument " "1"" of type '" "abac_role_t *""'"); 
+    }
+    arg1 = reinterpret_cast< abac_role_t * >(argp1);
+    res2 = SWIG_ConvertPtr(ST(1), &argp2,SWIGTYPE_p__abac_context_t, 0 |  0 );
+    if (!SWIG_IsOK(res2)) {
+      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "abac_role_short_string" "', argument " "2"" of type '" "abac_context_t *""'"); 
+    }
+    arg2 = reinterpret_cast< abac_context_t * >(argp2);
+    {
+      try {
+        result = (char *)abac_role_short_string(arg1,arg2);
+      }
+      catch (std::invalid_argument) {
+        croak("std::invalid_argument");
+      }
+      catch (std::logic_error) {
+        croak("std::logic_error");
+      }
+    }
+    ST(argvi) = SWIG_FromCharPtr((const char *)result); argvi++ ;
+    
+    
+    XSRETURN(argvi);
+  fail:
+    
+    
+    SWIG_croak_null();
+  }
+}
+
+
+XS(_wrap_abac_role_linked_role) {
+  {
+    abac_role_t *arg1 = (abac_role_t *) 0 ;
+    void *argp1 = 0 ;
+    int res1 = 0 ;
+    int argvi = 0;
+    char *result = 0 ;
+    dXSARGS;
+    
+    if ((items < 1) || (items > 1)) {
+      SWIG_croak("Usage: abac_role_linked_role(role);");
+    }
+    res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p__abac_role_t, 0 |  0 );
+    if (!SWIG_IsOK(res1)) {
+      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "abac_role_linked_role" "', argument " "1"" of type '" "abac_role_t *""'"); 
+    }
+    arg1 = reinterpret_cast< abac_role_t * >(argp1);
+    {
+      try {
+        result = (char *)abac_role_linked_role(arg1);
+      }
+      catch (std::invalid_argument) {
+        croak("std::invalid_argument");
+      }
+      catch (std::logic_error) {
+        croak("std::logic_error");
+      }
+    }
+    ST(argvi) = SWIG_FromCharPtr((const char *)result); argvi++ ;
+    
+    XSRETURN(argvi);
+  fail:
+    
+    SWIG_croak_null();
+  }
+}
+
+
+XS(_wrap_abac_role_linking_role) {
+  {
+    abac_role_t *arg1 = (abac_role_t *) 0 ;
+    void *argp1 = 0 ;
+    int res1 = 0 ;
+    int argvi = 0;
+    char *result = 0 ;
+    dXSARGS;
+    
+    if ((items < 1) || (items > 1)) {
+      SWIG_croak("Usage: abac_role_linking_role(role);");
+    }
+    res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p__abac_role_t, 0 |  0 );
+    if (!SWIG_IsOK(res1)) {
+      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "abac_role_linking_role" "', argument " "1"" of type '" "abac_role_t *""'"); 
+    }
+    arg1 = reinterpret_cast< abac_role_t * >(argp1);
+    {
+      try {
+        result = (char *)abac_role_linking_role(arg1);
+      }
+      catch (std::invalid_argument) {
+        croak("std::invalid_argument");
+      }
+      catch (std::logic_error) {
+        croak("std::logic_error");
+      }
+    }
+    ST(argvi) = SWIG_FromCharPtr((const char *)result); argvi++ ;
+    
+    XSRETURN(argvi);
+  fail:
+    
+    SWIG_croak_null();
+  }
+}
+
+
+XS(_wrap_abac_role_role_name) {
+  {
+    abac_role_t *arg1 = (abac_role_t *) 0 ;
+    void *argp1 = 0 ;
+    int res1 = 0 ;
+    int argvi = 0;
+    char *result = 0 ;
+    dXSARGS;
+    
+    if ((items < 1) || (items > 1)) {
+      SWIG_croak("Usage: abac_role_role_name(role);");
+    }
+    res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p__abac_role_t, 0 |  0 );
+    if (!SWIG_IsOK(res1)) {
+      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "abac_role_role_name" "', argument " "1"" of type '" "abac_role_t *""'"); 
+    }
+    arg1 = reinterpret_cast< abac_role_t * >(argp1);
+    {
+      try {
+        result = (char *)abac_role_role_name(arg1);
+      }
+      catch (std::invalid_argument) {
+        croak("std::invalid_argument");
+      }
+      catch (std::logic_error) {
+        croak("std::logic_error");
+      }
+    }
+    ST(argvi) = SWIG_FromCharPtr((const char *)result); argvi++ ;
+    
+    XSRETURN(argvi);
+  fail:
+    
+    SWIG_croak_null();
+  }
+}
+
+
+XS(_wrap_abac_role_principal) {
+  {
+    abac_role_t *arg1 = (abac_role_t *) 0 ;
+    void *argp1 = 0 ;
+    int res1 = 0 ;
+    int argvi = 0;
+    char *result = 0 ;
+    dXSARGS;
+    
+    if ((items < 1) || (items > 1)) {
+      SWIG_croak("Usage: abac_role_principal(role);");
+    }
+    res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p__abac_role_t, 0 |  0 );
+    if (!SWIG_IsOK(res1)) {
+      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "abac_role_principal" "', argument " "1"" of type '" "abac_role_t *""'"); 
+    }
+    arg1 = reinterpret_cast< abac_role_t * >(argp1);
+    {
+      try {
+        result = (char *)abac_role_principal(arg1);
+      }
+      catch (std::invalid_argument) {
+        croak("std::invalid_argument");
+      }
+      catch (std::logic_error) {
+        croak("std::logic_error");
+      }
+    }
+    ST(argvi) = SWIG_FromCharPtr((const char *)result); argvi++ ;
+    
+    XSRETURN(argvi);
+  fail:
+    
+    SWIG_croak_null();
+  }
+}
+
+
+XS(_wrap_abac_role_attr_key) {
+  {
+    abac_role_t *arg1 = (abac_role_t *) 0 ;
+    abac_role_t *arg2 = (abac_role_t *) 0 ;
+    void *argp1 = 0 ;
+    int res1 = 0 ;
+    void *argp2 = 0 ;
+    int res2 = 0 ;
+    int argvi = 0;
+    char *result = 0 ;
+    dXSARGS;
+    
+    if ((items < 2) || (items > 2)) {
+      SWIG_croak("Usage: abac_role_attr_key(head_role,tail_role);");
+    }
+    res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p__abac_role_t, 0 |  0 );
+    if (!SWIG_IsOK(res1)) {
+      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "abac_role_attr_key" "', argument " "1"" of type '" "abac_role_t *""'"); 
+    }
+    arg1 = reinterpret_cast< abac_role_t * >(argp1);
+    res2 = SWIG_ConvertPtr(ST(1), &argp2,SWIGTYPE_p__abac_role_t, 0 |  0 );
+    if (!SWIG_IsOK(res2)) {
+      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "abac_role_attr_key" "', argument " "2"" of type '" "abac_role_t *""'"); 
+    }
+    arg2 = reinterpret_cast< abac_role_t * >(argp2);
+    {
+      try {
+        result = (char *)abac_role_attr_key(arg1,arg2);
+      }
+      catch (std::invalid_argument) {
+        croak("std::invalid_argument");
+      }
+      catch (std::logic_error) {
+        croak("std::logic_error");
+      }
+    }
+    ST(argvi) = SWIG_FromCharPtr((const char *)result); argvi++ ;
+    
+    
+    XSRETURN(argvi);
+  fail:
+    
+    
+    SWIG_croak_null();
+  }
+}
+
+
+XS(_wrap_abac_id_from_file) {
+  {
+    char *arg1 = (char *) 0 ;
+    int res1 ;
+    char *buf1 = 0 ;
+    int alloc1 = 0 ;
+    int argvi = 0;
+    abac_id_t *result = 0 ;
+    dXSARGS;
+    
+    if ((items < 1) || (items > 1)) {
+      SWIG_croak("Usage: abac_id_from_file(char *);");
+    }
+    res1 = SWIG_AsCharPtrAndSize(ST(0), &buf1, NULL, &alloc1);
+    if (!SWIG_IsOK(res1)) {
+      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "abac_id_from_file" "', argument " "1"" of type '" "char *""'");
+    }
+    arg1 = reinterpret_cast< char * >(buf1);
+    {
+      try {
+        result = (abac_id_t *)abac_id_from_file(arg1);
+      }
+      catch (std::invalid_argument) {
+        croak("std::invalid_argument");
+      }
+      catch (std::logic_error) {
+        croak("std::logic_error");
+      }
+    }
+    ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__abac_id_t, 0 | 0); argvi++ ;
+    if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
+    XSRETURN(argvi);
+  fail:
+    if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
+    SWIG_croak_null();
+  }
+}
+
+
+XS(_wrap_abac_id_from_chunk) {
+  {
+    abac_chunk_t arg1 ;
+    int argvi = 0;
+    abac_id_t *result = 0 ;
+    dXSARGS;
+    
+    if ((items < 1) || (items > 1)) {
+      SWIG_croak("Usage: abac_id_from_chunk(chunk);");
+    }
+    {
+      STRLEN len;
+      (&arg1)->ptr = (unsigned char *)SvPV(ST(0), len);
+      (&arg1)->len = len;
+    }
+    {
+      try {
+        result = (abac_id_t *)abac_id_from_chunk(arg1);
+      }
+      catch (std::invalid_argument) {
+        croak("std::invalid_argument");
+      }
+      catch (std::logic_error) {
+        croak("std::logic_error");
+      }
+    }
+    ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__abac_id_t, 0 | 0); argvi++ ;
+    XSRETURN(argvi);
+  fail:
+    SWIG_croak_null();
+  }
+}
+
+
+XS(_wrap_abac_id_privkey_from_file) {
+  {
+    abac_id_t *arg1 = (abac_id_t *) 0 ;
+    char *arg2 = (char *) 0 ;
+    void *argp1 = 0 ;
+    int res1 = 0 ;
+    int res2 ;
+    char *buf2 = 0 ;
+    int alloc2 = 0 ;
+    int argvi = 0;
+    int result;
+    dXSARGS;
+    
+    if ((items < 2) || (items > 2)) {
+      SWIG_croak("Usage: abac_id_privkey_from_file(id,filename);");
+    }
+    res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p__abac_id_t, 0 |  0 );
+    if (!SWIG_IsOK(res1)) {
+      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "abac_id_privkey_from_file" "', argument " "1"" of type '" "abac_id_t *""'"); 
+    }
+    arg1 = reinterpret_cast< abac_id_t * >(argp1);
+    res2 = SWIG_AsCharPtrAndSize(ST(1), &buf2, NULL, &alloc2);
+    if (!SWIG_IsOK(res2)) {
+      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "abac_id_privkey_from_file" "', argument " "2"" of type '" "char *""'");
+    }
+    arg2 = reinterpret_cast< char * >(buf2);
+    {
+      try {
+        result = (int)abac_id_privkey_from_file(arg1,arg2);
+      }
+      catch (std::invalid_argument) {
+        croak("std::invalid_argument");
+      }
+      catch (std::logic_error) {
+        croak("std::logic_error");
+      }
+    }
+    ST(argvi) = SWIG_From_int  SWIG_PERL_CALL_ARGS_1(static_cast< int >(result)); argvi++ ;
+    
+    if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
+    XSRETURN(argvi);
+  fail:
+    
+    if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
+    SWIG_croak_null();
+  }
+}
+
+
+XS(_wrap_abac_id_privkey_from_chunk) {
+  {
+    abac_id_t *arg1 = (abac_id_t *) 0 ;
+    abac_chunk_t arg2 ;
+    void *argp1 = 0 ;
+    int res1 = 0 ;
+    int argvi = 0;
+    int result;
+    dXSARGS;
+    
+    if ((items < 2) || (items > 2)) {
+      SWIG_croak("Usage: abac_id_privkey_from_chunk(id,chunk);");
+    }
+    res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p__abac_id_t, 0 |  0 );
+    if (!SWIG_IsOK(res1)) {
+      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "abac_id_privkey_from_chunk" "', argument " "1"" of type '" "abac_id_t *""'"); 
+    }
+    arg1 = reinterpret_cast< abac_id_t * >(argp1);
+    {
+      STRLEN len;
+      (&arg2)->ptr = (unsigned char *)SvPV(ST(1), len);
+      (&arg2)->len = len;
+    }
+    {
+      try {
+        result = (int)abac_id_privkey_from_chunk(arg1,arg2);
+      }
+      catch (std::invalid_argument) {
+        croak("std::invalid_argument");
+      }
+      catch (std::logic_error) {
+        croak("std::logic_error");
+      }
+    }
+    ST(argvi) = SWIG_From_int  SWIG_PERL_CALL_ARGS_1(static_cast< int >(result)); argvi++ ;
+    
+    XSRETURN(argvi);
+  fail:
+    
+    SWIG_croak_null();
+  }
+}
+
+
+XS(_wrap_abac_id_generate) {
+  {
+    abac_id_t **arg1 = (abac_id_t **) 0 ;
+    char *arg2 = (char *) 0 ;
+    long arg3 ;
+    void *argp1 = 0 ;
+    int res1 = 0 ;
+    int res2 ;
+    char *buf2 = 0 ;
+    int alloc2 = 0 ;
+    long val3 ;
+    int ecode3 = 0 ;
+    int argvi = 0;
+    int result;
+    dXSARGS;
+    
+    if ((items < 3) || (items > 3)) {
+      SWIG_croak("Usage: abac_id_generate(ret,cn,validity);");
+    }
+    res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_p__abac_id_t, 0 |  0 );
+    if (!SWIG_IsOK(res1)) {
+      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "abac_id_generate" "', argument " "1"" of type '" "abac_id_t **""'"); 
+    }
+    arg1 = reinterpret_cast< abac_id_t ** >(argp1);
+    res2 = SWIG_AsCharPtrAndSize(ST(1), &buf2, NULL, &alloc2);
+    if (!SWIG_IsOK(res2)) {
+      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "abac_id_generate" "', argument " "2"" of type '" "char *""'");
+    }
+    arg2 = reinterpret_cast< char * >(buf2);
+    ecode3 = SWIG_AsVal_long SWIG_PERL_CALL_ARGS_2(ST(2), &val3);
+    if (!SWIG_IsOK(ecode3)) {
+      SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "abac_id_generate" "', argument " "3"" of type '" "long""'");
+    } 
+    arg3 = static_cast< long >(val3);
+    {
+      try {
+        result = (int)abac_id_generate(arg1,arg2,arg3);
+      }
+      catch (std::invalid_argument) {
+        croak("std::invalid_argument");
+      }
+      catch (std::logic_error) {
+        croak("std::logic_error");
+      }
+    }
+    ST(argvi) = SWIG_From_int  SWIG_PERL_CALL_ARGS_1(static_cast< int >(result)); argvi++ ;
+    
+    if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
+    
+    XSRETURN(argvi);
+  fail:
+    
+    if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
+    
+    SWIG_croak_null();
+  }
+}
+
+
+XS(_wrap_abac_id_generate_with_key) {
+  {
+    abac_id_t **arg1 = (abac_id_t **) 0 ;
+    char *arg2 = (char *) 0 ;
+    long arg3 ;
+    char *arg4 = (char *) 0 ;
+    void *argp1 = 0 ;
+    int res1 = 0 ;
+    int res2 ;
+    char *buf2 = 0 ;
+    int alloc2 = 0 ;
+    long val3 ;
+    int ecode3 = 0 ;
+    int res4 ;
+    char *buf4 = 0 ;
+    int alloc4 = 0 ;
+    int argvi = 0;
+    int result;
+    dXSARGS;
+    
+    if ((items < 4) || (items > 4)) {
+      SWIG_croak("Usage: abac_id_generate_with_key(ret,cn,validity,keyfile);");
+    }
+    res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_p__abac_id_t, 0 |  0 );
+    if (!SWIG_IsOK(res1)) {
+      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "abac_id_generate_with_key" "', argument " "1"" of type '" "abac_id_t **""'"); 
+    }
+    arg1 = reinterpret_cast< abac_id_t ** >(argp1);
+    res2 = SWIG_AsCharPtrAndSize(ST(1), &buf2, NULL, &alloc2);
+    if (!SWIG_IsOK(res2)) {
+      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "abac_id_generate_with_key" "', argument " "2"" of type '" "char *""'");
+    }
+    arg2 = reinterpret_cast< char * >(buf2);
+    ecode3 = SWIG_AsVal_long SWIG_PERL_CALL_ARGS_2(ST(2), &val3);
+    if (!SWIG_IsOK(ecode3)) {
+      SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "abac_id_generate_with_key" "', argument " "3"" of type '" "long""'");
+    } 
+    arg3 = static_cast< long >(val3);
+    res4 = SWIG_AsCharPtrAndSize(ST(3), &buf4, NULL, &alloc4);
+    if (!SWIG_IsOK(res4)) {
+      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "abac_id_generate_with_key" "', argument " "4"" of type '" "char *""'");
+    }
+    arg4 = reinterpret_cast< char * >(buf4);
+    {
+      try {
+        result = (int)abac_id_generate_with_key(arg1,arg2,arg3,arg4);
+      }
+      catch (std::invalid_argument) {
+        croak("std::invalid_argument");
+      }
+      catch (std::logic_error) {
+        croak("std::logic_error");
+      }
+    }
+    ST(argvi) = SWIG_From_int  SWIG_PERL_CALL_ARGS_1(static_cast< int >(result)); argvi++ ;
+    
+    if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
+    
+    if (alloc4 == SWIG_NEWOBJ) delete[] buf4;
+    XSRETURN(argvi);
+  fail:
+    
+    if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
+    
+    if (alloc4 == SWIG_NEWOBJ) delete[] buf4;
+    SWIG_croak_null();
+  }
+}
+
+
+XS(_wrap_abac_id_keyid) {
+  {
+    abac_id_t *arg1 = (abac_id_t *) 0 ;
+    void *argp1 = 0 ;
+    int res1 = 0 ;
+    int argvi = 0;
+    char *result = 0 ;
+    dXSARGS;
+    
+    if ((items < 1) || (items > 1)) {
+      SWIG_croak("Usage: abac_id_keyid(id);");
+    }
+    res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p__abac_id_t, 0 |  0 );
+    if (!SWIG_IsOK(res1)) {
+      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "abac_id_keyid" "', argument " "1"" of type '" "abac_id_t *""'"); 
+    }
+    arg1 = reinterpret_cast< abac_id_t * >(argp1);
+    {
+      try {
+        result = (char *)abac_id_keyid(arg1);
+      }
+      catch (std::invalid_argument) {
+        croak("std::invalid_argument");
+      }
+      catch (std::logic_error) {
+        croak("std::logic_error");
+      }
+    }
+    ST(argvi) = SWIG_FromCharPtr((const char *)result); argvi++ ;
+    
+    XSRETURN(argvi);
+  fail:
+    
+    SWIG_croak_null();
+  }
+}
+
+
+XS(_wrap_abac_id_cn) {
+  {
+    abac_id_t *arg1 = (abac_id_t *) 0 ;
+    void *argp1 = 0 ;
+    int res1 = 0 ;
+    int argvi = 0;
+    char *result = 0 ;
+    dXSARGS;
+    
+    if ((items < 1) || (items > 1)) {
+      SWIG_croak("Usage: abac_id_cn(id);");
+    }
+    res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p__abac_id_t, 0 |  0 );
+    if (!SWIG_IsOK(res1)) {
+      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "abac_id_cn" "', argument " "1"" of type '" "abac_id_t *""'"); 
+    }
+    arg1 = reinterpret_cast< abac_id_t * >(argp1);
+    {
+      try {
+        result = (char *)abac_id_cn(arg1);
+      }
+      catch (std::invalid_argument) {
+        croak("std::invalid_argument");
+      }
+      catch (std::logic_error) {
+        croak("std::logic_error");
+      }
+    }
+    ST(argvi) = SWIG_FromCharPtr((const char *)result); argvi++ ;
+    
+    XSRETURN(argvi);
+  fail:
+    
+    SWIG_croak_null();
+  }
+}
+
+
+XS(_wrap_abac_id_issuer) {
+  {
+    abac_id_t *arg1 = (abac_id_t *) 0 ;
+    void *argp1 = 0 ;
+    int res1 = 0 ;
+    int argvi = 0;
+    char *result = 0 ;
+    dXSARGS;
+    
+    if ((items < 1) || (items > 1)) {
+      SWIG_croak("Usage: abac_id_issuer(id);");
+    }
+    res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p__abac_id_t, 0 |  0 );
+    if (!SWIG_IsOK(res1)) {
+      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "abac_id_issuer" "', argument " "1"" of type '" "abac_id_t *""'"); 
+    }
+    arg1 = reinterpret_cast< abac_id_t * >(argp1);
+    {
+      try {
+        result = (char *)abac_id_issuer(arg1);
+      }
+      catch (std::invalid_argument) {
+        croak("std::invalid_argument");
+      }
+      catch (std::logic_error) {
+        croak("std::logic_error");
+      }
+    }
+    ST(argvi) = SWIG_FromCharPtr((const char *)result); argvi++ ;
+    
+    XSRETURN(argvi);
+  fail:
+    
+    SWIG_croak_null();
+  }
+}
+
+
+XS(_wrap_abac_id_subject) {
+  {
+    abac_id_t *arg1 = (abac_id_t *) 0 ;
+    void *argp1 = 0 ;
+    int res1 = 0 ;
+    int argvi = 0;
+    char *result = 0 ;
+    dXSARGS;
+    
+    if ((items < 1) || (items > 1)) {
+      SWIG_croak("Usage: abac_id_subject(id);");
+    }
+    res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p__abac_id_t, 0 |  0 );
+    if (!SWIG_IsOK(res1)) {
+      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "abac_id_subject" "', argument " "1"" of type '" "abac_id_t *""'"); 
+    }
+    arg1 = reinterpret_cast< abac_id_t * >(argp1);
+    {
+      try {
+        result = (char *)abac_id_subject(arg1);
+      }
+      catch (std::invalid_argument) {
+        croak("std::invalid_argument");
+      }
+      catch (std::logic_error) {
+        croak("std::logic_error");
+      }
+    }
+    ST(argvi) = SWIG_FromCharPtr((const char *)result); argvi++ ;
+    
+    XSRETURN(argvi);
+  fail:
+    
+    SWIG_croak_null();
+  }
+}
+
+
+XS(_wrap_abac_id_still_valid) {
+  {
+    abac_id_t *arg1 = (abac_id_t *) 0 ;
+    void *argp1 = 0 ;
+    int res1 = 0 ;
+    int argvi = 0;
+    int result;
+    dXSARGS;
+    
+    if ((items < 1) || (items > 1)) {
+      SWIG_croak("Usage: abac_id_still_valid(id);");
+    }
+    res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p__abac_id_t, 0 |  0 );
+    if (!SWIG_IsOK(res1)) {
+      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "abac_id_still_valid" "', argument " "1"" of type '" "abac_id_t *""'"); 
+    }
+    arg1 = reinterpret_cast< abac_id_t * >(argp1);
+    {
+      try {
+        result = (int)abac_id_still_valid(arg1);
+      }
+      catch (std::invalid_argument) {
+        croak("std::invalid_argument");
+      }
+      catch (std::logic_error) {
+        croak("std::logic_error");
+      }
+    }
+    ST(argvi) = SWIG_From_int  SWIG_PERL_CALL_ARGS_1(static_cast< int >(result)); argvi++ ;
+    
+    XSRETURN(argvi);
+  fail:
+    
+    SWIG_croak_null();
+  }
+}
+
+
+XS(_wrap_abac_id_has_keyid) {
+  {
+    abac_id_t *arg1 = (abac_id_t *) 0 ;
+    char *arg2 = (char *) 0 ;
+    void *argp1 = 0 ;
+    int res1 = 0 ;
+    int res2 ;
+    char *buf2 = 0 ;
+    int alloc2 = 0 ;
+    int argvi = 0;
+    int result;
+    dXSARGS;
+    
+    if ((items < 2) || (items > 2)) {
+      SWIG_croak("Usage: abac_id_has_keyid(id,char *);");
+    }
+    res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p__abac_id_t, 0 |  0 );
+    if (!SWIG_IsOK(res1)) {
+      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "abac_id_has_keyid" "', argument " "1"" of type '" "abac_id_t *""'"); 
+    }
+    arg1 = reinterpret_cast< abac_id_t * >(argp1);
+    res2 = SWIG_AsCharPtrAndSize(ST(1), &buf2, NULL, &alloc2);
+    if (!SWIG_IsOK(res2)) {
+      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "abac_id_has_keyid" "', argument " "2"" of type '" "char *""'");
+    }
+    arg2 = reinterpret_cast< char * >(buf2);
+    {
+      try {
+        result = (int)abac_id_has_keyid(arg1,arg2);
+      }
+      catch (std::invalid_argument) {
+        croak("std::invalid_argument");
+      }
+      catch (std::logic_error) {
+        croak("std::logic_error");
+      }
+    }
+    ST(argvi) = SWIG_From_int  SWIG_PERL_CALL_ARGS_1(static_cast< int >(result)); argvi++ ;
+    
+    if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
+    XSRETURN(argvi);
+  fail:
+    
+    if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
+    SWIG_croak_null();
+  }
+}
+
+
+XS(_wrap_abac_id_has_privkey) {
+  {
+    abac_id_t *arg1 = (abac_id_t *) 0 ;
+    void *argp1 = 0 ;
+    int res1 = 0 ;
+    int argvi = 0;
+    int result;
+    dXSARGS;
+    
+    if ((items < 1) || (items > 1)) {
+      SWIG_croak("Usage: abac_id_has_privkey(id);");
+    }
+    res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p__abac_id_t, 0 |  0 );
+    if (!SWIG_IsOK(res1)) {
+      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "abac_id_has_privkey" "', argument " "1"" of type '" "abac_id_t *""'"); 
+    }
+    arg1 = reinterpret_cast< abac_id_t * >(argp1);
+    {
+      try {
+        result = (int)abac_id_has_privkey(arg1);
+      }
+      catch (std::invalid_argument) {
+        croak("std::invalid_argument");
+      }
+      catch (std::logic_error) {
+        croak("std::logic_error");
+      }
+    }
+    ST(argvi) = SWIG_From_int  SWIG_PERL_CALL_ARGS_1(static_cast< int >(result)); argvi++ ;
+    
+    XSRETURN(argvi);
+  fail:
+    
+    SWIG_croak_null();
+  }
+}
+
+
+XS(_wrap_abac_id_validity) {
+  {
+    abac_id_t *arg1 = (abac_id_t *) 0 ;
+    tm *arg2 = (tm *) 0 ;
+    tm *arg3 = (tm *) 0 ;
+    void *argp1 = 0 ;
+    int res1 = 0 ;
+    void *argp2 = 0 ;
+    int res2 = 0 ;
+    void *argp3 = 0 ;
+    int res3 = 0 ;
+    int argvi = 0;
+    int result;
+    dXSARGS;
+    
+    if ((items < 3) || (items > 3)) {
+      SWIG_croak("Usage: abac_id_validity(id,not_before,not_after);");
+    }
+    res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p__abac_id_t, 0 |  0 );
+    if (!SWIG_IsOK(res1)) {
+      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "abac_id_validity" "', argument " "1"" of type '" "abac_id_t *""'"); 
+    }
+    arg1 = reinterpret_cast< abac_id_t * >(argp1);
+    res2 = SWIG_ConvertPtr(ST(1), &argp2,SWIGTYPE_p_tm, 0 |  0 );
+    if (!SWIG_IsOK(res2)) {
+      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "abac_id_validity" "', argument " "2"" of type '" "tm *""'"); 
+    }
+    arg2 = reinterpret_cast< tm * >(argp2);
+    res3 = SWIG_ConvertPtr(ST(2), &argp3,SWIGTYPE_p_tm, 0 |  0 );
+    if (!SWIG_IsOK(res3)) {
+      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "abac_id_validity" "', argument " "3"" of type '" "tm *""'"); 
+    }
+    arg3 = reinterpret_cast< tm * >(argp3);
+    {
+      try {
+        result = (int)abac_id_validity(arg1,arg2,arg3);
+      }
+      catch (std::invalid_argument) {
+        croak("std::invalid_argument");
+      }
+      catch (std::logic_error) {
+        croak("std::logic_error");
+      }
+    }
+    ST(argvi) = SWIG_From_int  SWIG_PERL_CALL_ARGS_1(static_cast< int >(result)); argvi++ ;
+    
+    
+    
+    XSRETURN(argvi);
+  fail:
+    
+    
+    
+    SWIG_croak_null();
+  }
+}
+
+
+XS(_wrap_abac_id_cert_filename) {
+  {
+    abac_id_t *arg1 = (abac_id_t *) 0 ;
+    void *argp1 = 0 ;
+    int res1 = 0 ;
+    int argvi = 0;
+    char *result = 0 ;
+    dXSARGS;
+    
+    if ((items < 1) || (items > 1)) {
+      SWIG_croak("Usage: abac_id_cert_filename(id);");
+    }
+    res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p__abac_id_t, 0 |  0 );
+    if (!SWIG_IsOK(res1)) {
+      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "abac_id_cert_filename" "', argument " "1"" of type '" "abac_id_t *""'"); 
+    }
+    arg1 = reinterpret_cast< abac_id_t * >(argp1);
+    {
+      try {
+        result = (char *)abac_id_cert_filename(arg1);
+      }
+      catch (std::invalid_argument) {
+        croak("std::invalid_argument");
+      }
+      catch (std::logic_error) {
+        croak("std::logic_error");
+      }
+    }
+    ST(argvi) = SWIG_FromCharPtr((const char *)result); argvi++ ;
+    
+    XSRETURN(argvi);
+  fail:
+    
+    SWIG_croak_null();
+  }
+}
+
+
+XS(_wrap_abac_id_write_cert) {
+  {
+    abac_id_t *arg1 = (abac_id_t *) 0 ;
+    FILE *arg2 = (FILE *) 0 ;
+    void *argp1 = 0 ;
+    int res1 = 0 ;
+    void *argp2 = 0 ;
+    int res2 = 0 ;
+    int argvi = 0;
+    int result;
+    dXSARGS;
+    
+    if ((items < 2) || (items > 2)) {
+      SWIG_croak("Usage: abac_id_write_cert(id,out);");
+    }
+    res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p__abac_id_t, 0 |  0 );
+    if (!SWIG_IsOK(res1)) {
+      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "abac_id_write_cert" "', argument " "1"" of type '" "abac_id_t *""'"); 
+    }
+    arg1 = reinterpret_cast< abac_id_t * >(argp1);
+    res2 = SWIG_ConvertPtr(ST(1), &argp2,SWIGTYPE_p_FILE, 0 |  0 );
+    if (!SWIG_IsOK(res2)) {
+      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "abac_id_write_cert" "', argument " "2"" of type '" "FILE *""'"); 
+    }
+    arg2 = reinterpret_cast< FILE * >(argp2);
+    {
+      try {
+        result = (int)abac_id_write_cert(arg1,arg2);
+      }
+      catch (std::invalid_argument) {
+        croak("std::invalid_argument");
+      }
+      catch (std::logic_error) {
+        croak("std::logic_error");
+      }
+    }
+    ST(argvi) = SWIG_From_int  SWIG_PERL_CALL_ARGS_1(static_cast< int >(result)); argvi++ ;
+    
+    
+    XSRETURN(argvi);
+  fail:
+    
+    
+    SWIG_croak_null();
+  }
+}
+
+
+XS(_wrap_abac_id_privkey_filename) {
+  {
+    abac_id_t *arg1 = (abac_id_t *) 0 ;
+    void *argp1 = 0 ;
+    int res1 = 0 ;
+    int argvi = 0;
+    char *result = 0 ;
+    dXSARGS;
+    
+    if ((items < 1) || (items > 1)) {
+      SWIG_croak("Usage: abac_id_privkey_filename(id);");
+    }
+    res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p__abac_id_t, 0 |  0 );
+    if (!SWIG_IsOK(res1)) {
+      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "abac_id_privkey_filename" "', argument " "1"" of type '" "abac_id_t *""'"); 
+    }
+    arg1 = reinterpret_cast< abac_id_t * >(argp1);
+    {
+      try {
+        result = (char *)abac_id_privkey_filename(arg1);
+      }
+      catch (std::invalid_argument) {
+        croak("std::invalid_argument");
+      }
+      catch (std::logic_error) {
+        croak("std::logic_error");
+      }
+    }
+    ST(argvi) = SWIG_FromCharPtr((const char *)result); argvi++ ;
+    
+    XSRETURN(argvi);
+  fail:
+    
+    SWIG_croak_null();
+  }
+}
+
+
+XS(_wrap_abac_id_write_privkey) {
+  {
+    abac_id_t *arg1 = (abac_id_t *) 0 ;
+    FILE *arg2 = (FILE *) 0 ;
+    void *argp1 = 0 ;
+    int res1 = 0 ;
+    void *argp2 = 0 ;
+    int res2 = 0 ;
+    int argvi = 0;
+    int result;
+    dXSARGS;
+    
+    if ((items < 2) || (items > 2)) {
+      SWIG_croak("Usage: abac_id_write_privkey(id,out);");
+    }
+    res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p__abac_id_t, 0 |  0 );
+    if (!SWIG_IsOK(res1)) {
+      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "abac_id_write_privkey" "', argument " "1"" of type '" "abac_id_t *""'"); 
+    }
+    arg1 = reinterpret_cast< abac_id_t * >(argp1);
+    res2 = SWIG_ConvertPtr(ST(1), &argp2,SWIGTYPE_p_FILE, 0 |  0 );
+    if (!SWIG_IsOK(res2)) {
+      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "abac_id_write_privkey" "', argument " "2"" of type '" "FILE *""'"); 
+    }
+    arg2 = reinterpret_cast< FILE * >(argp2);
+    {
+      try {
+        result = (int)abac_id_write_privkey(arg1,arg2);
+      }
+      catch (std::invalid_argument) {
+        croak("std::invalid_argument");
+      }
+      catch (std::logic_error) {
+        croak("std::logic_error");
+      }
+    }
+    ST(argvi) = SWIG_From_int  SWIG_PERL_CALL_ARGS_1(static_cast< int >(result)); argvi++ ;
+    
+    
+    XSRETURN(argvi);
+  fail:
+    
+    
+    SWIG_croak_null();
+  }
+}
+
+
+XS(_wrap_abac_id_cert_chunk) {
+  {
+    abac_id_t *arg1 = (abac_id_t *) 0 ;
+    void *argp1 = 0 ;
+    int res1 = 0 ;
+    int argvi = 0;
+    abac_chunk_t result;
+    dXSARGS;
+    
+    if ((items < 1) || (items > 1)) {
+      SWIG_croak("Usage: abac_id_cert_chunk(id);");
+    }
+    res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p__abac_id_t, 0 |  0 );
+    if (!SWIG_IsOK(res1)) {
+      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "abac_id_cert_chunk" "', argument " "1"" of type '" "abac_id_t *""'"); 
+    }
+    arg1 = reinterpret_cast< abac_id_t * >(argp1);
+    {
+      try {
+        result = abac_id_cert_chunk(arg1);
+      }
+      catch (std::invalid_argument) {
+        croak("std::invalid_argument");
+      }
+      catch (std::logic_error) {
+        croak("std::logic_error");
+      }
+    }
+    {
+      ST(argvi) = newSVpvn(
+        (const char *)(&result)->ptr,
+        (&result)->len
+        );
+      ++argvi;
+    }
+    
+    XSRETURN(argvi);
+  fail:
+    
+    SWIG_croak_null();
+  }
+}
+
+
+XS(_wrap_abac_id_privkey_chunk) {
+  {
+    abac_id_t *arg1 = (abac_id_t *) 0 ;
+    void *argp1 = 0 ;
+    int res1 = 0 ;
+    int argvi = 0;
+    abac_chunk_t result;
+    dXSARGS;
+    
+    if ((items < 1) || (items > 1)) {
+      SWIG_croak("Usage: abac_id_privkey_chunk(id);");
+    }
+    res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p__abac_id_t, 0 |  0 );
+    if (!SWIG_IsOK(res1)) {
+      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "abac_id_privkey_chunk" "', argument " "1"" of type '" "abac_id_t *""'"); 
+    }
+    arg1 = reinterpret_cast< abac_id_t * >(argp1);
+    {
+      try {
+        result = abac_id_privkey_chunk(arg1);
+      }
+      catch (std::invalid_argument) {
+        croak("std::invalid_argument");
+      }
+      catch (std::logic_error) {
+        croak("std::logic_error");
+      }
+    }
+    {
+      ST(argvi) = newSVpvn(
+        (const char *)(&result)->ptr,
+        (&result)->len
+        );
+      ++argvi;
+    }
+    
+    XSRETURN(argvi);
+  fail:
+    
+    SWIG_croak_null();
+  }
+}
+
+
+XS(_wrap_abac_id_dup) {
+  {
+    abac_id_t *arg1 = (abac_id_t *) 0 ;
+    void *argp1 = 0 ;
+    int res1 = 0 ;
+    int argvi = 0;
+    abac_id_t *result = 0 ;
+    dXSARGS;
+    
+    if ((items < 1) || (items > 1)) {
+      SWIG_croak("Usage: abac_id_dup(id);");
+    }
+    res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p__abac_id_t, 0 |  0 );
+    if (!SWIG_IsOK(res1)) {
+      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "abac_id_dup" "', argument " "1"" of type '" "abac_id_t *""'"); 
+    }
+    arg1 = reinterpret_cast< abac_id_t * >(argp1);
+    {
+      try {
+        result = (abac_id_t *)abac_id_dup(arg1);
+      }
+      catch (std::invalid_argument) {
+        croak("std::invalid_argument");
+      }
+      catch (std::logic_error) {
+        croak("std::logic_error");
+      }
+    }
+    ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__abac_id_t, 0 | 0); argvi++ ;
+    
+    XSRETURN(argvi);
+  fail:
+    
+    SWIG_croak_null();
+  }
+}
+
+
+XS(_wrap_abac_id_free) {
+  {
+    abac_id_t *arg1 = (abac_id_t *) 0 ;
+    void *argp1 = 0 ;
+    int res1 = 0 ;
+    int argvi = 0;
+    dXSARGS;
+    
+    if ((items < 1) || (items > 1)) {
+      SWIG_croak("Usage: abac_id_free(id);");
+    }
+    res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p__abac_id_t, 0 |  0 );
+    if (!SWIG_IsOK(res1)) {
+      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "abac_id_free" "', argument " "1"" of type '" "abac_id_t *""'"); 
+    }
+    arg1 = reinterpret_cast< abac_id_t * >(argp1);
+    {
+      try {
+        abac_id_free(arg1);
+      }
+      catch (std::invalid_argument) {
+        croak("std::invalid_argument");
+      }
+      catch (std::logic_error) {
+        croak("std::logic_error");
+      }
+    }
+    ST(argvi) = sv_newmortal();
+    
+    XSRETURN(argvi);
+  fail:
+    
+    SWIG_croak_null();
+  }
+}
+
+
+XS(_wrap_abac_attribute_create) {
+  {
+    abac_attribute_t **arg1 = (abac_attribute_t **) 0 ;
+    abac_id_t *arg2 = (abac_id_t *) 0 ;
+    char *arg3 = (char *) 0 ;
+    long arg4 ;
+    void *argp1 = 0 ;
+    int res1 = 0 ;
+    void *argp2 = 0 ;
+    int res2 = 0 ;
+    int res3 ;
+    char *buf3 = 0 ;
+    int alloc3 = 0 ;
+    long val4 ;
+    int ecode4 = 0 ;
+    int argvi = 0;
+    int result;
+    dXSARGS;
+    
+    if ((items < 4) || (items > 4)) {
+      SWIG_croak("Usage: abac_attribute_create(attr,issuer,role,validity);");
+    }
+    res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_p__abac_attribute_t, 0 |  0 );
+    if (!SWIG_IsOK(res1)) {
+      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "abac_attribute_create" "', argument " "1"" of type '" "abac_attribute_t **""'"); 
+    }
+    arg1 = reinterpret_cast< abac_attribute_t ** >(argp1);
+    res2 = SWIG_ConvertPtr(ST(1), &argp2,SWIGTYPE_p__abac_id_t, 0 |  0 );
+    if (!SWIG_IsOK(res2)) {
+      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "abac_attribute_create" "', argument " "2"" of type '" "abac_id_t *""'"); 
+    }
+    arg2 = reinterpret_cast< abac_id_t * >(argp2);
+    res3 = SWIG_AsCharPtrAndSize(ST(2), &buf3, NULL, &alloc3);
+    if (!SWIG_IsOK(res3)) {
+      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "abac_attribute_create" "', argument " "3"" of type '" "char *""'");
+    }
+    arg3 = reinterpret_cast< char * >(buf3);
+    ecode4 = SWIG_AsVal_long SWIG_PERL_CALL_ARGS_2(ST(3), &val4);
+    if (!SWIG_IsOK(ecode4)) {
+      SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "abac_attribute_create" "', argument " "4"" of type '" "long""'");
+    } 
+    arg4 = static_cast< long >(val4);
+    {
+      try {
+        result = (int)abac_attribute_create(arg1,arg2,arg3,arg4);
+      }
+      catch (std::invalid_argument) {
+        croak("std::invalid_argument");
+      }
+      catch (std::logic_error) {
+        croak("std::logic_error");
+      }
+    }
+    ST(argvi) = SWIG_From_int  SWIG_PERL_CALL_ARGS_1(static_cast< int >(result)); argvi++ ;
+    
+    
+    if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
+    
+    XSRETURN(argvi);
+  fail:
+    
+    
+    if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
+    
+    SWIG_croak_null();
+  }
+}
+
+
+XS(_wrap_abac_attribute_set_head) {
+  {
+    abac_attribute_t *arg1 = (abac_attribute_t *) 0 ;
+    char *arg2 = (char *) 0 ;
+    void *argp1 = 0 ;
+    int res1 = 0 ;
+    int res2 ;
+    char *buf2 = 0 ;
+    int alloc2 = 0 ;
+    int argvi = 0;
+    dXSARGS;
+    
+    if ((items < 2) || (items > 2)) {
+      SWIG_croak("Usage: abac_attribute_set_head(attr,string);");
+    }
+    res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p__abac_attribute_t, 0 |  0 );
+    if (!SWIG_IsOK(res1)) {
+      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "abac_attribute_set_head" "', argument " "1"" of type '" "abac_attribute_t *""'"); 
+    }
+    arg1 = reinterpret_cast< abac_attribute_t * >(argp1);
+    res2 = SWIG_AsCharPtrAndSize(ST(1), &buf2, NULL, &alloc2);
+    if (!SWIG_IsOK(res2)) {
+      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "abac_attribute_set_head" "', argument " "2"" of type '" "char *""'");
+    }
+    arg2 = reinterpret_cast< char * >(buf2);
+    {
+      try {
+        abac_attribute_set_head(arg1,arg2);
+      }
+      catch (std::invalid_argument) {
+        croak("std::invalid_argument");
+      }
+      catch (std::logic_error) {
+        croak("std::logic_error");
+      }
+    }
+    ST(argvi) = sv_newmortal();
+    
+    if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
+    XSRETURN(argvi);
+  fail:
+    
+    if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
+    SWIG_croak_null();
+  }
+}
+
+
+XS(_wrap_abac_attribute_get_head) {
+  {
+    abac_attribute_t *arg1 = (abac_attribute_t *) 0 ;
+    void *argp1 = 0 ;
+    int res1 = 0 ;
+    int argvi = 0;
+    char *result = 0 ;
+    dXSARGS;
+    
+    if ((items < 1) || (items > 1)) {
+      SWIG_croak("Usage: abac_attribute_get_head(abac_attribute_t *);");
+    }
+    res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p__abac_attribute_t, 0 |  0 );
+    if (!SWIG_IsOK(res1)) {
+      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "abac_attribute_get_head" "', argument " "1"" of type '" "abac_attribute_t *""'"); 
+    }
+    arg1 = reinterpret_cast< abac_attribute_t * >(argp1);
+    {
+      try {
+        result = (char *)abac_attribute_get_head(arg1);
+      }
+      catch (std::invalid_argument) {
+        croak("std::invalid_argument");
+      }
+      catch (std::logic_error) {
+        croak("std::logic_error");
+      }
+    }
+    ST(argvi) = SWIG_FromCharPtr((const char *)result); argvi++ ;
+    
+    XSRETURN(argvi);
+  fail:
+    
+    SWIG_croak_null();
+  }
+}
+
+
+XS(_wrap_abac_attribute_principal) {
+  {
+    abac_attribute_t *arg1 = (abac_attribute_t *) 0 ;
+    char *arg2 = (char *) 0 ;
+    void *argp1 = 0 ;
+    int res1 = 0 ;
+    int res2 ;
+    char *buf2 = 0 ;
+    int alloc2 = 0 ;
+    int argvi = 0;
+    int result;
+    dXSARGS;
+    
+    if ((items < 2) || (items > 2)) {
+      SWIG_croak("Usage: abac_attribute_principal(attr,keyid);");
+    }
+    res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p__abac_attribute_t, 0 |  0 );
+    if (!SWIG_IsOK(res1)) {
+      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "abac_attribute_principal" "', argument " "1"" of type '" "abac_attribute_t *""'"); 
+    }
+    arg1 = reinterpret_cast< abac_attribute_t * >(argp1);
+    res2 = SWIG_AsCharPtrAndSize(ST(1), &buf2, NULL, &alloc2);
+    if (!SWIG_IsOK(res2)) {
+      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "abac_attribute_principal" "', argument " "2"" of type '" "char *""'");
+    }
+    arg2 = reinterpret_cast< char * >(buf2);
+    {
+      try {
+        result = (int)abac_attribute_principal(arg1,arg2);
+      }
+      catch (std::invalid_argument) {
+        croak("std::invalid_argument");
+      }
+      catch (std::logic_error) {
+        croak("std::logic_error");
+      }
+    }
+    ST(argvi) = SWIG_From_int  SWIG_PERL_CALL_ARGS_1(static_cast< int >(result)); argvi++ ;
+    
+    if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
+    XSRETURN(argvi);
+  fail:
+    
+    if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
+    SWIG_croak_null();
+  }
+}
+
+
+XS(_wrap_abac_attribute_role) {
+  {
+    abac_attribute_t *arg1 = (abac_attribute_t *) 0 ;
+    char *arg2 = (char *) 0 ;
+    char *arg3 = (char *) 0 ;
+    void *argp1 = 0 ;
+    int res1 = 0 ;
+    int res2 ;
+    char *buf2 = 0 ;
+    int alloc2 = 0 ;
+    int res3 ;
+    char *buf3 = 0 ;
+    int alloc3 = 0 ;
+    int argvi = 0;
+    int result;
+    dXSARGS;
+    
+    if ((items < 3) || (items > 3)) {
+      SWIG_croak("Usage: abac_attribute_role(attr,keyid,role);");
+    }
+    res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p__abac_attribute_t, 0 |  0 );
+    if (!SWIG_IsOK(res1)) {
+      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "abac_attribute_role" "', argument " "1"" of type '" "abac_attribute_t *""'"); 
+    }
+    arg1 = reinterpret_cast< abac_attribute_t * >(argp1);
+    res2 = SWIG_AsCharPtrAndSize(ST(1), &buf2, NULL, &alloc2);
+    if (!SWIG_IsOK(res2)) {
+      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "abac_attribute_role" "', argument " "2"" of type '" "char *""'");
+    }
+    arg2 = reinterpret_cast< char * >(buf2);
+    res3 = SWIG_AsCharPtrAndSize(ST(2), &buf3, NULL, &alloc3);
+    if (!SWIG_IsOK(res3)) {
+      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "abac_attribute_role" "', argument " "3"" of type '" "char *""'");
+    }
+    arg3 = reinterpret_cast< char * >(buf3);
+    {
+      try {
+        result = (int)abac_attribute_role(arg1,arg2,arg3);
+      }
+      catch (std::invalid_argument) {
+        croak("std::invalid_argument");
+      }
+      catch (std::logic_error) {
+        croak("std::logic_error");
+      }
+    }
+    ST(argvi) = SWIG_From_int  SWIG_PERL_CALL_ARGS_1(static_cast< int >(result)); argvi++ ;
+    
+    if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
+    if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
+    XSRETURN(argvi);
+  fail:
+    
+    if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
+    if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
+    SWIG_croak_null();
+  }
+}
+
+
+XS(_wrap_abac_attribute_linking_role) {
+  {
+    abac_attribute_t *arg1 = (abac_attribute_t *) 0 ;
+    char *arg2 = (char *) 0 ;
+    char *arg3 = (char *) 0 ;
+    char *arg4 = (char *) 0 ;
+    void *argp1 = 0 ;
+    int res1 = 0 ;
+    int res2 ;
+    char *buf2 = 0 ;
+    int alloc2 = 0 ;
+    int res3 ;
+    char *buf3 = 0 ;
+    int alloc3 = 0 ;
+    int res4 ;
+    char *buf4 = 0 ;
+    int alloc4 = 0 ;
+    int argvi = 0;
+    int result;
+    dXSARGS;
+    
+    if ((items < 4) || (items > 4)) {
+      SWIG_croak("Usage: abac_attribute_linking_role(attr,keyid,role,linked);");
+    }
+    res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p__abac_attribute_t, 0 |  0 );
+    if (!SWIG_IsOK(res1)) {
+      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "abac_attribute_linking_role" "', argument " "1"" of type '" "abac_attribute_t *""'"); 
+    }
+    arg1 = reinterpret_cast< abac_attribute_t * >(argp1);
+    res2 = SWIG_AsCharPtrAndSize(ST(1), &buf2, NULL, &alloc2);
+    if (!SWIG_IsOK(res2)) {
+      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "abac_attribute_linking_role" "', argument " "2"" of type '" "char *""'");
+    }
+    arg2 = reinterpret_cast< char * >(buf2);
+    res3 = SWIG_AsCharPtrAndSize(ST(2), &buf3, NULL, &alloc3);
+    if (!SWIG_IsOK(res3)) {
+      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "abac_attribute_linking_role" "', argument " "3"" of type '" "char *""'");
+    }
+    arg3 = reinterpret_cast< char * >(buf3);
+    res4 = SWIG_AsCharPtrAndSize(ST(3), &buf4, NULL, &alloc4);
+    if (!SWIG_IsOK(res4)) {
+      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "abac_attribute_linking_role" "', argument " "4"" of type '" "char *""'");
+    }
+    arg4 = reinterpret_cast< char * >(buf4);
+    {
+      try {
+        result = (int)abac_attribute_linking_role(arg1,arg2,arg3,arg4);
+      }
+      catch (std::invalid_argument) {
+        croak("std::invalid_argument");
+      }
+      catch (std::logic_error) {
+        croak("std::logic_error");
+      }
+    }
+    ST(argvi) = SWIG_From_int  SWIG_PERL_CALL_ARGS_1(static_cast< int >(result)); argvi++ ;
+    
+    if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
+    if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
+    if (alloc4 == SWIG_NEWOBJ) delete[] buf4;
+    XSRETURN(argvi);
+  fail:
+    
+    if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
+    if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
+    if (alloc4 == SWIG_NEWOBJ) delete[] buf4;
+    SWIG_croak_null();
+  }
+}
+
+
+XS(_wrap_abac_attribute_bake) {
+  {
+    abac_attribute_t *arg1 = (abac_attribute_t *) 0 ;
+    void *argp1 = 0 ;
+    int res1 = 0 ;
+    int argvi = 0;
+    int result;
+    dXSARGS;
+    
+    if ((items < 1) || (items > 1)) {
+      SWIG_croak("Usage: abac_attribute_bake(attr);");
+    }
+    res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p__abac_attribute_t, 0 |  0 );
+    if (!SWIG_IsOK(res1)) {
+      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "abac_attribute_bake" "', argument " "1"" of type '" "abac_attribute_t *""'"); 
+    }
+    arg1 = reinterpret_cast< abac_attribute_t * >(argp1);
+    {
+      try {
+        result = (int)abac_attribute_bake(arg1);
+      }
+      catch (std::invalid_argument) {
+        croak("std::invalid_argument");
+      }
+      catch (std::logic_error) {
+        croak("std::logic_error");
+      }
+    }
+    ST(argvi) = SWIG_From_int  SWIG_PERL_CALL_ARGS_1(static_cast< int >(result)); argvi++ ;
+    
+    XSRETURN(argvi);
+  fail:
+    
+    SWIG_croak_null();
+  }
+}
+
+
+XS(_wrap_abac_attribute_bake_context) {
+  {
+    abac_attribute_t *arg1 = (abac_attribute_t *) 0 ;
+    abac_context_t *arg2 = (abac_context_t *) 0 ;
+    void *argp1 = 0 ;
+    int res1 = 0 ;
+    void *argp2 = 0 ;
+    int res2 = 0 ;
+    int argvi = 0;
+    int result;
+    dXSARGS;
+    
+    if ((items < 2) || (items > 2)) {
+      SWIG_croak("Usage: abac_attribute_bake_context(attr,ctxt);");
+    }
+    res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p__abac_attribute_t, 0 |  0 );
+    if (!SWIG_IsOK(res1)) {
+      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "abac_attribute_bake_context" "', argument " "1"" of type '" "abac_attribute_t *""'"); 
+    }
+    arg1 = reinterpret_cast< abac_attribute_t * >(argp1);
+    res2 = SWIG_ConvertPtr(ST(1), &argp2,SWIGTYPE_p__abac_context_t, 0 |  0 );
+    if (!SWIG_IsOK(res2)) {
+      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "abac_attribute_bake_context" "', argument " "2"" of type '" "abac_context_t *""'"); 
+    }
+    arg2 = reinterpret_cast< abac_context_t * >(argp2);
+    {
+      try {
+        result = (int)abac_attribute_bake_context(arg1,arg2);
+      }
+      catch (std::invalid_argument) {
+        croak("std::invalid_argument");
+      }
+      catch (std::logic_error) {
+        croak("std::logic_error");
+      }
+    }
+    ST(argvi) = SWIG_From_int  SWIG_PERL_CALL_ARGS_1(static_cast< int >(result)); argvi++ ;
+    
+    
+    XSRETURN(argvi);
+  fail:
+    
+    
+    SWIG_croak_null();
+  }
+}
+
+
+XS(_wrap_abac_attribute_baked) {
+  {
+    abac_attribute_t *arg1 = (abac_attribute_t *) 0 ;
+    void *argp1 = 0 ;
+    int res1 = 0 ;
+    int argvi = 0;
+    int result;
+    dXSARGS;
+    
+    if ((items < 1) || (items > 1)) {
+      SWIG_croak("Usage: abac_attribute_baked(attr);");
+    }
+    res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p__abac_attribute_t, 0 |  0 );
+    if (!SWIG_IsOK(res1)) {
+      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "abac_attribute_baked" "', argument " "1"" of type '" "abac_attribute_t *""'"); 
+    }
+    arg1 = reinterpret_cast< abac_attribute_t * >(argp1);
+    {
+      try {
+        result = (int)abac_attribute_baked(arg1);
+      }
+      catch (std::invalid_argument) {
+        croak("std::invalid_argument");
+      }
+      catch (std::logic_error) {
+        croak("std::logic_error");
+      }
+    }
+    ST(argvi) = SWIG_From_int  SWIG_PERL_CALL_ARGS_1(static_cast< int >(result)); argvi++ ;
+    
+    XSRETURN(argvi);
+  fail:
+    
+    SWIG_croak_null();
+  }
+}
+
+
+XS(_wrap_abac_attribute_write) {
+  {
+    abac_attribute_t *arg1 = (abac_attribute_t *) 0 ;
+    FILE *arg2 = (FILE *) 0 ;
+    void *argp1 = 0 ;
+    int res1 = 0 ;
+    void *argp2 = 0 ;
+    int res2 = 0 ;
+    int argvi = 0;
+    int result;
+    dXSARGS;
+    
+    if ((items < 2) || (items > 2)) {
+      SWIG_croak("Usage: abac_attribute_write(attr,out);");
+    }
+    res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p__abac_attribute_t, 0 |  0 );
+    if (!SWIG_IsOK(res1)) {
+      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "abac_attribute_write" "', argument " "1"" of type '" "abac_attribute_t *""'"); 
+    }
+    arg1 = reinterpret_cast< abac_attribute_t * >(argp1);
+    res2 = SWIG_ConvertPtr(ST(1), &argp2,SWIGTYPE_p_FILE, 0 |  0 );
+    if (!SWIG_IsOK(res2)) {
+      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "abac_attribute_write" "', argument " "2"" of type '" "FILE *""'"); 
+    }
+    arg2 = reinterpret_cast< FILE * >(argp2);
+    {
+      try {
+        result = (int)abac_attribute_write(arg1,arg2);
+      }
+      catch (std::invalid_argument) {
+        croak("std::invalid_argument");
+      }
+      catch (std::logic_error) {
+        croak("std::logic_error");
+      }
+    }
+    ST(argvi) = SWIG_From_int  SWIG_PERL_CALL_ARGS_1(static_cast< int >(result)); argvi++ ;
+    
+    
+    XSRETURN(argvi);
+  fail:
+    
+    
+    SWIG_croak_null();
+  }
+}
+
+
+XS(_wrap_abac_attribute_write_file) {
+  {
+    abac_attribute_t *arg1 = (abac_attribute_t *) 0 ;
+    char *arg2 = (char *) 0 ;
+    void *argp1 = 0 ;
+    int res1 = 0 ;
+    int res2 ;
+    char *buf2 = 0 ;
+    int alloc2 = 0 ;
+    int argvi = 0;
+    int result;
+    dXSARGS;
+    
+    if ((items < 2) || (items > 2)) {
+      SWIG_croak("Usage: abac_attribute_write_file(attr,fname);");
+    }
+    res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p__abac_attribute_t, 0 |  0 );
+    if (!SWIG_IsOK(res1)) {
+      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "abac_attribute_write_file" "', argument " "1"" of type '" "abac_attribute_t *""'"); 
+    }
+    arg1 = reinterpret_cast< abac_attribute_t * >(argp1);
+    res2 = SWIG_AsCharPtrAndSize(ST(1), &buf2, NULL, &alloc2);
+    if (!SWIG_IsOK(res2)) {
+      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "abac_attribute_write_file" "', argument " "2"" of type '" "char const *""'");
+    }
+    arg2 = reinterpret_cast< char * >(buf2);
+    {
+      try {
+        result = (int)abac_attribute_write_file(arg1,(char const *)arg2);
+      }
+      catch (std::invalid_argument) {
+        croak("std::invalid_argument");
+      }
+      catch (std::logic_error) {
+        croak("std::logic_error");
+      }
+    }
+    ST(argvi) = SWIG_From_int  SWIG_PERL_CALL_ARGS_1(static_cast< int >(result)); argvi++ ;
+    
+    if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
+    XSRETURN(argvi);
+  fail:
+    
+    if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
+    SWIG_croak_null();
+  }
+}
+
+
+XS(_wrap_abac_attribute_get_ntails) {
+  {
+    abac_attribute_t *arg1 = (abac_attribute_t *) 0 ;
+    void *argp1 = 0 ;
+    int res1 = 0 ;
+    int argvi = 0;
+    int result;
+    dXSARGS;
+    
+    if ((items < 1) || (items > 1)) {
+      SWIG_croak("Usage: abac_attribute_get_ntails(a);");
+    }
+    res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p__abac_attribute_t, 0 |  0 );
+    if (!SWIG_IsOK(res1)) {
+      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "abac_attribute_get_ntails" "', argument " "1"" of type '" "abac_attribute_t *""'"); 
+    }
+    arg1 = reinterpret_cast< abac_attribute_t * >(argp1);
+    {
+      try {
+        result = (int)abac_attribute_get_ntails(arg1);
+      }
+      catch (std::invalid_argument) {
+        croak("std::invalid_argument");
+      }
+      catch (std::logic_error) {
+        croak("std::logic_error");
+      }
+    }
+    ST(argvi) = SWIG_From_int  SWIG_PERL_CALL_ARGS_1(static_cast< int >(result)); argvi++ ;
+    
+    XSRETURN(argvi);
+  fail:
+    
+    SWIG_croak_null();
+  }
+}
+
+
+XS(_wrap_abac_attribute_get_tail_n) {
+  {
+    abac_attribute_t *arg1 = (abac_attribute_t *) 0 ;
+    int arg2 ;
+    void *argp1 = 0 ;
+    int res1 = 0 ;
+    int val2 ;
+    int ecode2 = 0 ;
+    int argvi = 0;
+    char *result = 0 ;
+    dXSARGS;
+    
+    if ((items < 2) || (items > 2)) {
+      SWIG_croak("Usage: abac_attribute_get_tail_n(a,n);");
+    }
+    res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p__abac_attribute_t, 0 |  0 );
+    if (!SWIG_IsOK(res1)) {
+      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "abac_attribute_get_tail_n" "', argument " "1"" of type '" "abac_attribute_t *""'"); 
+    }
+    arg1 = reinterpret_cast< abac_attribute_t * >(argp1);
+    ecode2 = SWIG_AsVal_int SWIG_PERL_CALL_ARGS_2(ST(1), &val2);
+    if (!SWIG_IsOK(ecode2)) {
+      SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "abac_attribute_get_tail_n" "', argument " "2"" of type '" "int""'");
+    } 
+    arg2 = static_cast< int >(val2);
+    {
+      try {
+        result = (char *)abac_attribute_get_tail_n(arg1,arg2);
+      }
+      catch (std::invalid_argument) {
+        croak("std::invalid_argument");
+      }
+      catch (std::logic_error) {
+        croak("std::logic_error");
+      }
+    }
+    ST(argvi) = SWIG_FromCharPtr((const char *)result); argvi++ ;
+    
+    
+    XSRETURN(argvi);
+  fail:
+    
+    
+    SWIG_croak_null();
+  }
+}
+
+
+XS(_wrap_abac_attribute_cert_chunk) {
+  {
+    abac_attribute_t *arg1 = (abac_attribute_t *) 0 ;
+    void *argp1 = 0 ;
+    int res1 = 0 ;
+    int argvi = 0;
+    abac_chunk_t result;
+    dXSARGS;
+    
+    if ((items < 1) || (items > 1)) {
+      SWIG_croak("Usage: abac_attribute_cert_chunk(abac_attribute_t *);");
+    }
+    res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p__abac_attribute_t, 0 |  0 );
+    if (!SWIG_IsOK(res1)) {
+      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "abac_attribute_cert_chunk" "', argument " "1"" of type '" "abac_attribute_t *""'"); 
+    }
+    arg1 = reinterpret_cast< abac_attribute_t * >(argp1);
+    {
+      try {
+        result = abac_attribute_cert_chunk(arg1);
+      }
+      catch (std::invalid_argument) {
+        croak("std::invalid_argument");
+      }
+      catch (std::logic_error) {
+        croak("std::logic_error");
+      }
+    }
+    {
+      ST(argvi) = newSVpvn(
+        (const char *)(&result)->ptr,
+        (&result)->len
+        );
+      ++argvi;
+    }
+    
+    XSRETURN(argvi);
+  fail:
+    
+    SWIG_croak_null();
+  }
+}
+
+
+XS(_wrap_abac_attribute_free) {
+  {
+    abac_attribute_t *arg1 = (abac_attribute_t *) 0 ;
+    void *argp1 = 0 ;
+    int res1 = 0 ;
+    int argvi = 0;
+    dXSARGS;
+    
+    if ((items < 1) || (items > 1)) {
+      SWIG_croak("Usage: abac_attribute_free(abac_attribute_t *);");
+    }
+    res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p__abac_attribute_t, 0 |  0 );
+    if (!SWIG_IsOK(res1)) {
+      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "abac_attribute_free" "', argument " "1"" of type '" "abac_attribute_t *""'"); 
+    }
+    arg1 = reinterpret_cast< abac_attribute_t * >(argp1);
+    {
+      try {
+        abac_attribute_free(arg1);
+      }
+      catch (std::invalid_argument) {
+        croak("std::invalid_argument");
+      }
+      catch (std::logic_error) {
+        croak("std::logic_error");
+      }
+    }
+    ST(argvi) = sv_newmortal();
+    
+    XSRETURN(argvi);
+  fail:
+    
+    SWIG_croak_null();
+  }
+}
+
+
+XS(_wrap_abac_attribute_certs_from_file) {
+  {
+    ABAC_LIST_T *arg1 = (ABAC_LIST_T *) 0 ;
+    char *arg2 = (char *) 0 ;
+    void *argp1 = 0 ;
+    int res1 = 0 ;
+    int res2 ;
+    char *buf2 = 0 ;
+    int alloc2 = 0 ;
+    int argvi = 0;
+    ABAC_LIST_T *result = 0 ;
+    dXSARGS;
+    
+    if ((items < 2) || (items > 2)) {
+      SWIG_croak("Usage: abac_attribute_certs_from_file(ABAC_LIST_T *,char *);");
+    }
+    res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p__abac_list_t, 0 |  0 );
+    if (!SWIG_IsOK(res1)) {
+      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "abac_attribute_certs_from_file" "', argument " "1"" of type '" "ABAC_LIST_T *""'"); 
+    }
+    arg1 = reinterpret_cast< ABAC_LIST_T * >(argp1);
+    res2 = SWIG_AsCharPtrAndSize(ST(1), &buf2, NULL, &alloc2);
+    if (!SWIG_IsOK(res2)) {
+      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "abac_attribute_certs_from_file" "', argument " "2"" of type '" "char *""'");
+    }
+    arg2 = reinterpret_cast< char * >(buf2);
+    {
+      try {
+        result = (ABAC_LIST_T *)abac_attribute_certs_from_file(arg1,arg2);
+      }
+      catch (std::invalid_argument) {
+        croak("std::invalid_argument");
+      }
+      catch (std::logic_error) {
+        croak("std::logic_error");
+      }
+    }
+    ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__abac_list_t, 0 | 0); argvi++ ;
+    
+    if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
+    XSRETURN(argvi);
+  fail:
+    
+    if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
+    SWIG_croak_null();
+  }
+}
+
+
+XS(_wrap_abac_attribute_certs_from_chunk) {
+  {
+    ABAC_LIST_T *arg1 = (ABAC_LIST_T *) 0 ;
+    abac_chunk_t arg2 ;
+    void *argp1 = 0 ;
+    int res1 = 0 ;
+    int argvi = 0;
+    ABAC_LIST_T *result = 0 ;
+    dXSARGS;
+    
+    if ((items < 2) || (items > 2)) {
+      SWIG_croak("Usage: abac_attribute_certs_from_chunk(ABAC_LIST_T *,abac_chunk_t);");
+    }
+    res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p__abac_list_t, 0 |  0 );
+    if (!SWIG_IsOK(res1)) {
+      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "abac_attribute_certs_from_chunk" "', argument " "1"" of type '" "ABAC_LIST_T *""'"); 
+    }
+    arg1 = reinterpret_cast< ABAC_LIST_T * >(argp1);
+    {
+      STRLEN len;
+      (&arg2)->ptr = (unsigned char *)SvPV(ST(1), len);
+      (&arg2)->len = len;
+    }
+    {
+      try {
+        result = (ABAC_LIST_T *)abac_attribute_certs_from_chunk(arg1,arg2);
+      }
+      catch (std::invalid_argument) {
+        croak("std::invalid_argument");
+      }
+      catch (std::logic_error) {
+        croak("std::logic_error");
+      }
+    }
+    ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__abac_list_t, 0 | 0); argvi++ ;
+    
+    XSRETURN(argvi);
+  fail:
+    
+    SWIG_croak_null();
+  }
+}
+
+
+XS(_wrap_abac_attribute_role_string) {
+  {
+    abac_attribute_t *arg1 = (abac_attribute_t *) 0 ;
+    void *argp1 = 0 ;
+    int res1 = 0 ;
+    int argvi = 0;
+    char *result = 0 ;
+    dXSARGS;
+    
+    if ((items < 1) || (items > 1)) {
+      SWIG_croak("Usage: abac_attribute_role_string(attr);");
+    }
+    res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p__abac_attribute_t, 0 |  0 );
+    if (!SWIG_IsOK(res1)) {
+      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "abac_attribute_role_string" "', argument " "1"" of type '" "abac_attribute_t *""'"); 
+    }
+    arg1 = reinterpret_cast< abac_attribute_t * >(argp1);
+    {
+      try {
+        result = (char *)abac_attribute_role_string(arg1);
+      }
+      catch (std::invalid_argument) {
+        croak("std::invalid_argument");
+      }
+      catch (std::logic_error) {
+        croak("std::logic_error");
+      }
+    }
+    ST(argvi) = SWIG_FromCharPtr((const char *)result); argvi++ ;
+    
+    XSRETURN(argvi);
+  fail:
+    
+    SWIG_croak_null();
+  }
+}
+
+
+XS(_wrap_abac_attribute_issuer_id) {
+  {
+    abac_attribute_t *arg1 = (abac_attribute_t *) 0 ;
+    void *argp1 = 0 ;
+    int res1 = 0 ;
+    int argvi = 0;
+    abac_id_t *result = 0 ;
+    dXSARGS;
+    
+    if ((items < 1) || (items > 1)) {
+      SWIG_croak("Usage: abac_attribute_issuer_id(ptr);");
+    }
+    res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p__abac_attribute_t, 0 |  0 );
+    if (!SWIG_IsOK(res1)) {
+      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "abac_attribute_issuer_id" "', argument " "1"" of type '" "abac_attribute_t *""'"); 
+    }
+    arg1 = reinterpret_cast< abac_attribute_t * >(argp1);
+    {
+      try {
+        result = (abac_id_t *)abac_attribute_issuer_id(arg1);
+      }
+      catch (std::invalid_argument) {
+        croak("std::invalid_argument");
+      }
+      catch (std::logic_error) {
+        croak("std::logic_error");
+      }
+    }
+    ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__abac_id_t, 0 | 0); argvi++ ;
+    
+    XSRETURN(argvi);
+  fail:
+    
+    SWIG_croak_null();
+  }
+}
+
+
+XS(_wrap_abac_attribute_get_output_format) {
+  {
+    abac_attribute_t *arg1 = (abac_attribute_t *) 0 ;
+    void *argp1 = 0 ;
+    int res1 = 0 ;
+    int argvi = 0;
+    char *result = 0 ;
+    dXSARGS;
+    
+    if ((items < 1) || (items > 1)) {
+      SWIG_croak("Usage: abac_attribute_get_output_format(abac_attribute_t *);");
+    }
+    res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p__abac_attribute_t, 0 |  0 );
+    if (!SWIG_IsOK(res1)) {
+      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "abac_attribute_get_output_format" "', argument " "1"" of type '" "abac_attribute_t *""'"); 
+    }
+    arg1 = reinterpret_cast< abac_attribute_t * >(argp1);
+    {
+      try {
+        result = (char *)abac_attribute_get_output_format(arg1);
+      }
+      catch (std::invalid_argument) {
+        croak("std::invalid_argument");
+      }
+      catch (std::logic_error) {
+        croak("std::logic_error");
+      }
+    }
+    ST(argvi) = SWIG_FromCharPtr((const char *)result); argvi++ ;
+    
+    XSRETURN(argvi);
+  fail:
+    
+    SWIG_croak_null();
+  }
+}
+
+
+XS(_wrap_abac_attribute_set_output_format) {
+  {
+    abac_attribute_t *arg1 = (abac_attribute_t *) 0 ;
+    char *arg2 = (char *) 0 ;
+    void *argp1 = 0 ;
+    int res1 = 0 ;
+    int res2 ;
+    char *buf2 = 0 ;
+    int alloc2 = 0 ;
+    int argvi = 0;
+    dXSARGS;
+    
+    if ((items < 2) || (items > 2)) {
+      SWIG_croak("Usage: abac_attribute_set_output_format(abac_attribute_t *,char *);");
+    }
+    res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p__abac_attribute_t, 0 |  0 );
+    if (!SWIG_IsOK(res1)) {
+      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "abac_attribute_set_output_format" "', argument " "1"" of type '" "abac_attribute_t *""'"); 
+    }
+    arg1 = reinterpret_cast< abac_attribute_t * >(argp1);
+    res2 = SWIG_AsCharPtrAndSize(ST(1), &buf2, NULL, &alloc2);
+    if (!SWIG_IsOK(res2)) {
+      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "abac_attribute_set_output_format" "', argument " "2"" of type '" "char *""'");
+    }
+    arg2 = reinterpret_cast< char * >(buf2);
+    {
+      try {
+        abac_attribute_set_output_format(arg1,arg2);
+      }
+      catch (std::invalid_argument) {
+        croak("std::invalid_argument");
+      }
+      catch (std::logic_error) {
+        croak("std::logic_error");
+      }
+    }
+    ST(argvi) = sv_newmortal();
+    
+    if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
+    XSRETURN(argvi);
+  fail:
+    
+    if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
+    SWIG_croak_null();
+  }
+}
+
+
+XS(_wrap_abac_attribute_validity) {
+  {
+    abac_attribute_t *arg1 = (abac_attribute_t *) 0 ;
+    tm *arg2 = (tm *) 0 ;
+    tm *arg3 = (tm *) 0 ;
+    void *argp1 = 0 ;
+    int res1 = 0 ;
+    void *argp2 = 0 ;
+    int res2 = 0 ;
+    void *argp3 = 0 ;
+    int res3 = 0 ;
+    int argvi = 0;
+    int result;
+    dXSARGS;
+    
+    if ((items < 3) || (items > 3)) {
+      SWIG_croak("Usage: abac_attribute_validity(attr,not_before,not_after);");
+    }
+    res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p__abac_attribute_t, 0 |  0 );
+    if (!SWIG_IsOK(res1)) {
+      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "abac_attribute_validity" "', argument " "1"" of type '" "abac_attribute_t *""'"); 
+    }
+    arg1 = reinterpret_cast< abac_attribute_t * >(argp1);
+    res2 = SWIG_ConvertPtr(ST(1), &argp2,SWIGTYPE_p_tm, 0 |  0 );
+    if (!SWIG_IsOK(res2)) {
+      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "abac_attribute_validity" "', argument " "2"" of type '" "tm *""'"); 
+    }
+    arg2 = reinterpret_cast< tm * >(argp2);
+    res3 = SWIG_ConvertPtr(ST(2), &argp3,SWIGTYPE_p_tm, 0 |  0 );
+    if (!SWIG_IsOK(res3)) {
+      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "abac_attribute_validity" "', argument " "3"" of type '" "tm *""'"); 
+    }
+    arg3 = reinterpret_cast< tm * >(argp3);
+    {
+      try {
+        result = (int)abac_attribute_validity(arg1,arg2,arg3);
+      }
+      catch (std::invalid_argument) {
+        croak("std::invalid_argument");
+      }
+      catch (std::logic_error) {
+        croak("std::logic_error");
+      }
+    }
+    ST(argvi) = SWIG_From_int  SWIG_PERL_CALL_ARGS_1(static_cast< int >(result)); argvi++ ;
+    
+    
+    
+    XSRETURN(argvi);
+  fail:
+    
+    
+    
+    SWIG_croak_null();
+  }
+}
+
+
+XS(_wrap_abac_attribute_get_keyid_map) {
+  {
+    abac_attribute_t *arg1 = (abac_attribute_t *) 0 ;
+    void *argp1 = 0 ;
+    int res1 = 0 ;
+    int argvi = 0;
+    abac_keyid_map_t *result = 0 ;
+    dXSARGS;
+    
+    if ((items < 1) || (items > 1)) {
+      SWIG_croak("Usage: abac_attribute_get_keyid_map(abac_attribute_t *);");
+    }
+    res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p__abac_attribute_t, 0 |  0 );
+    if (!SWIG_IsOK(res1)) {
+      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "abac_attribute_get_keyid_map" "', argument " "1"" of type '" "abac_attribute_t *""'"); 
+    }
+    arg1 = reinterpret_cast< abac_attribute_t * >(argp1);
+    {
+      try {
+        result = (abac_keyid_map_t *)abac_attribute_get_keyid_map(arg1);
+      }
+      catch (std::invalid_argument) {
+        croak("std::invalid_argument");
+      }
+      catch (std::logic_error) {
+        croak("std::logic_error");
+      }
+    }
+    ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_abac_keyid_map_t, 0 | 0); argvi++ ;
+    
+    XSRETURN(argvi);
+  fail:
+    
+    SWIG_croak_null();
+  }
+}
+
+
+XS(_wrap_abac_attribute_get_principal) {
+  {
+    abac_attribute_t *arg1 = (abac_attribute_t *) 0 ;
+    void *argp1 = 0 ;
+    int res1 = 0 ;
+    int argvi = 0;
+    char *result = 0 ;
+    dXSARGS;
+    
+    if ((items < 1) || (items > 1)) {
+      SWIG_croak("Usage: abac_attribute_get_principal(attr);");
+    }
+    res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p__abac_attribute_t, 0 |  0 );
+    if (!SWIG_IsOK(res1)) {
+      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "abac_attribute_get_principal" "', argument " "1"" of type '" "abac_attribute_t *""'"); 
+    }
+    arg1 = reinterpret_cast< abac_attribute_t * >(argp1);
+    {
+      try {
+        result = (char *)abac_attribute_get_principal(arg1);
+      }
+      catch (std::invalid_argument) {
+        croak("std::invalid_argument");
+      }
+      catch (std::logic_error) {
+        croak("std::logic_error");
+      }
+    }
+    ST(argvi) = SWIG_FromCharPtr((const char *)result); argvi++ ;
+    
+    XSRETURN(argvi);
+  fail:
+    
+    SWIG_croak_null();
+  }
+}
+
+
+XS(_wrap_abac_attribute_still_valid) {
+  {
+    abac_attribute_t *arg1 = (abac_attribute_t *) 0 ;
+    void *argp1 = 0 ;
+    int res1 = 0 ;
+    int argvi = 0;
+    int result;
+    dXSARGS;
+    
+    if ((items < 1) || (items > 1)) {
+      SWIG_croak("Usage: abac_attribute_still_valid(attr);");
+    }
+    res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p__abac_attribute_t, 0 |  0 );
+    if (!SWIG_IsOK(res1)) {
+      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "abac_attribute_still_valid" "', argument " "1"" of type '" "abac_attribute_t *""'"); 
+    }
+    arg1 = reinterpret_cast< abac_attribute_t * >(argp1);
+    {
+      try {
+        result = (int)abac_attribute_still_valid(arg1);
+      }
+      catch (std::invalid_argument) {
+        croak("std::invalid_argument");
+      }
+      catch (std::logic_error) {
+        croak("std::logic_error");
+      }
+    }
+    ST(argvi) = SWIG_From_int  SWIG_PERL_CALL_ARGS_1(static_cast< int >(result)); argvi++ ;
+    
+    XSRETURN(argvi);
+  fail:
+    
+    SWIG_croak_null();
+  }
+}
+
+
+XS(_wrap_abac_keyid_mapping_new) {
+  {
+    char *arg1 = (char *) 0 ;
+    char *arg2 = (char *) 0 ;
+    int res1 ;
+    char *buf1 = 0 ;
+    int alloc1 = 0 ;
+    int res2 ;
+    char *buf2 = 0 ;
+    int alloc2 = 0 ;
+    int argvi = 0;
+    abac_keyid_mapping_t *result = 0 ;
+    dXSARGS;
+    
+    if ((items < 2) || (items > 2)) {
+      SWIG_croak("Usage: abac_keyid_mapping_new(k,v);");
+    }
+    res1 = SWIG_AsCharPtrAndSize(ST(0), &buf1, NULL, &alloc1);
+    if (!SWIG_IsOK(res1)) {
+      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "abac_keyid_mapping_new" "', argument " "1"" of type '" "char *""'");
+    }
+    arg1 = reinterpret_cast< char * >(buf1);
+    res2 = SWIG_AsCharPtrAndSize(ST(1), &buf2, NULL, &alloc2);
+    if (!SWIG_IsOK(res2)) {
+      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "abac_keyid_mapping_new" "', argument " "2"" of type '" "char *""'");
+    }
+    arg2 = reinterpret_cast< char * >(buf2);
+    {
+      try {
+        result = (abac_keyid_mapping_t *)abac_keyid_mapping_new(arg1,arg2);
+      }
+      catch (std::invalid_argument) {
+        croak("std::invalid_argument");
+      }
+      catch (std::logic_error) {
+        croak("std::logic_error");
+      }
+    }
+    ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_abac_keyid_mapping_t, 0 | 0); argvi++ ;
+    if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
+    if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
+    XSRETURN(argvi);
+  fail:
+    if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
+    if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
+    SWIG_croak_null();
+  }
+}
+
+
+XS(_wrap_abac_keyid_mapping_free) {
+  {
+    abac_keyid_mapping_t *arg1 = (abac_keyid_mapping_t *) 0 ;
+    void *argp1 = 0 ;
+    int res1 = 0 ;
+    int argvi = 0;
+    dXSARGS;
+    
+    if ((items < 1) || (items > 1)) {
+      SWIG_croak("Usage: abac_keyid_mapping_free(m);");
+    }
+    res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_abac_keyid_mapping_t, 0 |  0 );
+    if (!SWIG_IsOK(res1)) {
+      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "abac_keyid_mapping_free" "', argument " "1"" of type '" "abac_keyid_mapping_t *""'"); 
+    }
+    arg1 = reinterpret_cast< abac_keyid_mapping_t * >(argp1);
+    {
+      try {
+        abac_keyid_mapping_free(arg1);
+      }
+      catch (std::invalid_argument) {
+        croak("std::invalid_argument");
+      }
+      catch (std::logic_error) {
+        croak("std::logic_error");
+      }
+    }
+    ST(argvi) = sv_newmortal();
+    
+    XSRETURN(argvi);
+  fail:
+    
+    SWIG_croak_null();
+  }
+}
+
+
+XS(_wrap_abac_keyid_map_new) {
+  {
+    int argvi = 0;
+    abac_keyid_map_t *result = 0 ;
+    dXSARGS;
+    
+    if ((items < 0) || (items > 0)) {
+      SWIG_croak("Usage: abac_keyid_map_new();");
+    }
+    {
+      try {
+        result = (abac_keyid_map_t *)abac_keyid_map_new();
+      }
+      catch (std::invalid_argument) {
+        croak("std::invalid_argument");
+      }
+      catch (std::logic_error) {
+        croak("std::logic_error");
+      }
+    }
+    ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_abac_keyid_map_t, 0 | 0); argvi++ ;
+    XSRETURN(argvi);
+  fail:
+    SWIG_croak_null();
+  }
+}
+
+
+XS(_wrap_abac_keyid_map_dup) {
+  {
+    abac_keyid_map_t *arg1 = (abac_keyid_map_t *) 0 ;
+    void *argp1 = 0 ;
+    int res1 = 0 ;
+    int argvi = 0;
+    abac_keyid_map_t *result = 0 ;
+    dXSARGS;
+    
+    if ((items < 1) || (items > 1)) {
+      SWIG_croak("Usage: abac_keyid_map_dup(abac_keyid_map_t *);");
+    }
+    res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_abac_keyid_map_t, 0 |  0 );
+    if (!SWIG_IsOK(res1)) {
+      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "abac_keyid_map_dup" "', argument " "1"" of type '" "abac_keyid_map_t *""'"); 
+    }
+    arg1 = reinterpret_cast< abac_keyid_map_t * >(argp1);
+    {
+      try {
+        result = (abac_keyid_map_t *)abac_keyid_map_dup(arg1);
+      }
+      catch (std::invalid_argument) {
+        croak("std::invalid_argument");
+      }
+      catch (std::logic_error) {
+        croak("std::logic_error");
+      }
+    }
+    ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_abac_keyid_map_t, 0 | 0); argvi++ ;
+    
+    XSRETURN(argvi);
+  fail:
+    
+    SWIG_croak_null();
+  }
+}
+
+
+XS(_wrap_abac_keyid_map_clone) {
+  {
+    abac_keyid_map_t *arg1 = (abac_keyid_map_t *) 0 ;
+    void *argp1 = 0 ;
+    int res1 = 0 ;
+    int argvi = 0;
+    abac_keyid_map_t *result = 0 ;
+    dXSARGS;
+    
+    if ((items < 1) || (items > 1)) {
+      SWIG_croak("Usage: abac_keyid_map_clone(abac_keyid_map_t *);");
+    }
+    res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_abac_keyid_map_t, 0 |  0 );
+    if (!SWIG_IsOK(res1)) {
+      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "abac_keyid_map_clone" "', argument " "1"" of type '" "abac_keyid_map_t *""'"); 
+    }
+    arg1 = reinterpret_cast< abac_keyid_map_t * >(argp1);
+    {
+      try {
+        result = (abac_keyid_map_t *)abac_keyid_map_clone(arg1);
+      }
+      catch (std::invalid_argument) {
+        croak("std::invalid_argument");
+      }
+      catch (std::logic_error) {
+        croak("std::logic_error");
+      }
+    }
+    ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_abac_keyid_map_t, 0 | 0); argvi++ ;
+    
+    XSRETURN(argvi);
+  fail:
+    
+    SWIG_croak_null();
+  }
+}
+
+
+XS(_wrap_abac_keyid_map_free) {
+  {
+    abac_keyid_map_t *arg1 = (abac_keyid_map_t *) 0 ;
+    void *argp1 = 0 ;
+    int res1 = 0 ;
+    int argvi = 0;
+    dXSARGS;
+    
+    if ((items < 1) || (items > 1)) {
+      SWIG_croak("Usage: abac_keyid_map_free(m);");
+    }
+    res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_abac_keyid_map_t, 0 |  0 );
+    if (!SWIG_IsOK(res1)) {
+      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "abac_keyid_map_free" "', argument " "1"" of type '" "abac_keyid_map_t *""'"); 
+    }
+    arg1 = reinterpret_cast< abac_keyid_map_t * >(argp1);
+    {
+      try {
+        abac_keyid_map_free(arg1);
+      }
+      catch (std::invalid_argument) {
+        croak("std::invalid_argument");
+      }
+      catch (std::logic_error) {
+        croak("std::logic_error");
+      }
+    }
+    ST(argvi) = sv_newmortal();
+    
+    XSRETURN(argvi);
+  fail:
+    
+    SWIG_croak_null();
+  }
+}
+
+
+XS(_wrap_abac_keyid_map_key_to_nickname) {
+  {
+    abac_keyid_map_t *arg1 = (abac_keyid_map_t *) 0 ;
+    char *arg2 = (char *) 0 ;
+    void *argp1 = 0 ;
+    int res1 = 0 ;
+    int res2 ;
+    char *buf2 = 0 ;
+    int alloc2 = 0 ;
+    int argvi = 0;
+    char *result = 0 ;
+    dXSARGS;
+    
+    if ((items < 2) || (items > 2)) {
+      SWIG_croak("Usage: abac_keyid_map_key_to_nickname(m,key);");
+    }
+    res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_abac_keyid_map_t, 0 |  0 );
+    if (!SWIG_IsOK(res1)) {
+      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "abac_keyid_map_key_to_nickname" "', argument " "1"" of type '" "abac_keyid_map_t *""'"); 
+    }
+    arg1 = reinterpret_cast< abac_keyid_map_t * >(argp1);
+    res2 = SWIG_AsCharPtrAndSize(ST(1), &buf2, NULL, &alloc2);
+    if (!SWIG_IsOK(res2)) {
+      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "abac_keyid_map_key_to_nickname" "', argument " "2"" of type '" "char *""'");
+    }
+    arg2 = reinterpret_cast< char * >(buf2);
+    {
+      try {
+        result = (char *)abac_keyid_map_key_to_nickname(arg1,arg2);
+      }
+      catch (std::invalid_argument) {
+        croak("std::invalid_argument");
+      }
+      catch (std::logic_error) {
+        croak("std::logic_error");
+      }
+    }
+    ST(argvi) = SWIG_FromCharPtr((const char *)result); argvi++ ;
+    
+    if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
+    XSRETURN(argvi);
+  fail:
+    
+    if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
+    SWIG_croak_null();
+  }
+}
+
+
+XS(_wrap_abac_keyid_map_nickname_to_key) {
+  {
+    abac_keyid_map_t *arg1 = (abac_keyid_map_t *) 0 ;
+    char *arg2 = (char *) 0 ;
+    void *argp1 = 0 ;
+    int res1 = 0 ;
+    int res2 ;
+    char *buf2 = 0 ;
+    int alloc2 = 0 ;
+    int argvi = 0;
+    char *result = 0 ;
+    dXSARGS;
+    
+    if ((items < 2) || (items > 2)) {
+      SWIG_croak("Usage: abac_keyid_map_nickname_to_key(m,nick);");
+    }
+    res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_abac_keyid_map_t, 0 |  0 );
+    if (!SWIG_IsOK(res1)) {
+      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "abac_keyid_map_nickname_to_key" "', argument " "1"" of type '" "abac_keyid_map_t *""'"); 
+    }
+    arg1 = reinterpret_cast< abac_keyid_map_t * >(argp1);
+    res2 = SWIG_AsCharPtrAndSize(ST(1), &buf2, NULL, &alloc2);
+    if (!SWIG_IsOK(res2)) {
+      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "abac_keyid_map_nickname_to_key" "', argument " "2"" of type '" "char *""'");
+    }
+    arg2 = reinterpret_cast< char * >(buf2);
+    {
+      try {
+        result = (char *)abac_keyid_map_nickname_to_key(arg1,arg2);
+      }
+      catch (std::invalid_argument) {
+        croak("std::invalid_argument");
+      }
+      catch (std::logic_error) {
+        croak("std::logic_error");
+      }
+    }
+    ST(argvi) = SWIG_FromCharPtr((const char *)result); argvi++ ;
+    
+    if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
+    XSRETURN(argvi);
+  fail:
+    
+    if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
+    SWIG_croak_null();
+  }
+}
+
+
+XS(_wrap_abac_keyid_map_remove_keyid) {
+  {
+    abac_keyid_map_t *arg1 = (abac_keyid_map_t *) 0 ;
+    char *arg2 = (char *) 0 ;
+    void *argp1 = 0 ;
+    int res1 = 0 ;
+    int res2 ;
+    char *buf2 = 0 ;
+    int alloc2 = 0 ;
+    int argvi = 0;
+    int result;
+    dXSARGS;
+    
+    if ((items < 2) || (items > 2)) {
+      SWIG_croak("Usage: abac_keyid_map_remove_keyid(m,key);");
+    }
+    res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_abac_keyid_map_t, 0 |  0 );
+    if (!SWIG_IsOK(res1)) {
+      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "abac_keyid_map_remove_keyid" "', argument " "1"" of type '" "abac_keyid_map_t *""'"); 
+    }
+    arg1 = reinterpret_cast< abac_keyid_map_t * >(argp1);
+    res2 = SWIG_AsCharPtrAndSize(ST(1), &buf2, NULL, &alloc2);
+    if (!SWIG_IsOK(res2)) {
+      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "abac_keyid_map_remove_keyid" "', argument " "2"" of type '" "char *""'");
+    }
+    arg2 = reinterpret_cast< char * >(buf2);
+    {
+      try {
+        result = (int)abac_keyid_map_remove_keyid(arg1,arg2);
+      }
+      catch (std::invalid_argument) {
+        croak("std::invalid_argument");
+      }
+      catch (std::logic_error) {
+        croak("std::logic_error");
+      }
+    }
+    ST(argvi) = SWIG_From_int  SWIG_PERL_CALL_ARGS_1(static_cast< int >(result)); argvi++ ;
+    
+    if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
+    XSRETURN(argvi);
+  fail:
+    
+    if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
+    SWIG_croak_null();
+  }
+}
+
+
+XS(_wrap_abac_keyid_map_add_nickname) {
+  {
+    abac_keyid_map_t *arg1 = (abac_keyid_map_t *) 0 ;
+    char *arg2 = (char *) 0 ;
+    char *arg3 = (char *) 0 ;
+    void *argp1 = 0 ;
+    int res1 = 0 ;
+    int res2 ;
+    char *buf2 = 0 ;
+    int alloc2 = 0 ;
+    int res3 ;
+    char *buf3 = 0 ;
+    int alloc3 = 0 ;
+    int argvi = 0;
+    int result;
+    dXSARGS;
+    
+    if ((items < 3) || (items > 3)) {
+      SWIG_croak("Usage: abac_keyid_map_add_nickname(m,key,nick);");
+    }
+    res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_abac_keyid_map_t, 0 |  0 );
+    if (!SWIG_IsOK(res1)) {
+      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "abac_keyid_map_add_nickname" "', argument " "1"" of type '" "abac_keyid_map_t *""'"); 
+    }
+    arg1 = reinterpret_cast< abac_keyid_map_t * >(argp1);
+    res2 = SWIG_AsCharPtrAndSize(ST(1), &buf2, NULL, &alloc2);
+    if (!SWIG_IsOK(res2)) {
+      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "abac_keyid_map_add_nickname" "', argument " "2"" of type '" "char *""'");
+    }
+    arg2 = reinterpret_cast< char * >(buf2);
+    res3 = SWIG_AsCharPtrAndSize(ST(2), &buf3, NULL, &alloc3);
+    if (!SWIG_IsOK(res3)) {
+      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "abac_keyid_map_add_nickname" "', argument " "3"" of type '" "char *""'");
+    }
+    arg3 = reinterpret_cast< char * >(buf3);
+    {
+      try {
+        result = (int)abac_keyid_map_add_nickname(arg1,arg2,arg3);
+      }
+      catch (std::invalid_argument) {
+        croak("std::invalid_argument");
+      }
+      catch (std::logic_error) {
+        croak("std::logic_error");
+      }
+    }
+    ST(argvi) = SWIG_From_int  SWIG_PERL_CALL_ARGS_1(static_cast< int >(result)); argvi++ ;
+    
+    if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
+    if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
+    XSRETURN(argvi);
+  fail:
+    
+    if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
+    if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
+    SWIG_croak_null();
+  }
+}
+
+
+XS(_wrap_abac_keyid_map_merge) {
+  {
+    abac_keyid_map_t *arg1 = (abac_keyid_map_t *) 0 ;
+    abac_keyid_map_t *arg2 = (abac_keyid_map_t *) 0 ;
+    int arg3 ;
+    void *argp1 = 0 ;
+    int res1 = 0 ;
+    void *argp2 = 0 ;
+    int res2 = 0 ;
+    int val3 ;
+    int ecode3 = 0 ;
+    int argvi = 0;
+    dXSARGS;
+    
+    if ((items < 3) || (items > 3)) {
+      SWIG_croak("Usage: abac_keyid_map_merge(d,s,overwrite);");
+    }
+    res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_abac_keyid_map_t, 0 |  0 );
+    if (!SWIG_IsOK(res1)) {
+      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "abac_keyid_map_merge" "', argument " "1"" of type '" "abac_keyid_map_t *""'"); 
+    }
+    arg1 = reinterpret_cast< abac_keyid_map_t * >(argp1);
+    res2 = SWIG_ConvertPtr(ST(1), &argp2,SWIGTYPE_p_abac_keyid_map_t, 0 |  0 );
+    if (!SWIG_IsOK(res2)) {
+      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "abac_keyid_map_merge" "', argument " "2"" of type '" "abac_keyid_map_t *""'"); 
+    }
+    arg2 = reinterpret_cast< abac_keyid_map_t * >(argp2);
+    ecode3 = SWIG_AsVal_int SWIG_PERL_CALL_ARGS_2(ST(2), &val3);
+    if (!SWIG_IsOK(ecode3)) {
+      SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "abac_keyid_map_merge" "', argument " "3"" of type '" "int""'");
+    } 
+    arg3 = static_cast< int >(val3);
+    {
+      try {
+        abac_keyid_map_merge(arg1,arg2,arg3);
+      }
+      catch (std::invalid_argument) {
+        croak("std::invalid_argument");
+      }
+      catch (std::logic_error) {
+        croak("std::logic_error");
+      }
+    }
+    ST(argvi) = sv_newmortal();
+    
+    
+    
+    XSRETURN(argvi);
+  fail:
+    
+    
+    
+    SWIG_croak_null();
+  }
+}
+
+
+XS(_wrap_abac_keyid_map_expand_key) {
+  {
+    abac_keyid_map_t *arg1 = (abac_keyid_map_t *) 0 ;
+    char *arg2 = (char *) 0 ;
+    void *argp1 = 0 ;
+    int res1 = 0 ;
+    int res2 ;
+    char *buf2 = 0 ;
+    int alloc2 = 0 ;
+    int argvi = 0;
+    char *result = 0 ;
+    dXSARGS;
+    
+    if ((items < 2) || (items > 2)) {
+      SWIG_croak("Usage: abac_keyid_map_expand_key(m,s);");
+    }
+    res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_abac_keyid_map_t, 0 |  0 );
+    if (!SWIG_IsOK(res1)) {
+      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "abac_keyid_map_expand_key" "', argument " "1"" of type '" "abac_keyid_map_t *""'"); 
+    }
+    arg1 = reinterpret_cast< abac_keyid_map_t * >(argp1);
+    res2 = SWIG_AsCharPtrAndSize(ST(1), &buf2, NULL, &alloc2);
+    if (!SWIG_IsOK(res2)) {
+      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "abac_keyid_map_expand_key" "', argument " "2"" of type '" "char *""'");
+    }
+    arg2 = reinterpret_cast< char * >(buf2);
+    {
+      try {
+        result = (char *)abac_keyid_map_expand_key(arg1,arg2);
+      }
+      catch (std::invalid_argument) {
+        croak("std::invalid_argument");
+      }
+      catch (std::logic_error) {
+        croak("std::logic_error");
+      }
+    }
+    ST(argvi) = SWIG_FromCharPtr((const char *)result); argvi++ ;
+    
+    if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
+    XSRETURN(argvi);
+  fail:
+    
+    if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
+    SWIG_croak_null();
+  }
+}
+
+
+XS(_wrap_abac_keyid_map_expand_nickname) {
+  {
+    abac_keyid_map_t *arg1 = (abac_keyid_map_t *) 0 ;
+    char *arg2 = (char *) 0 ;
+    void *argp1 = 0 ;
+    int res1 = 0 ;
+    int res2 ;
+    char *buf2 = 0 ;
+    int alloc2 = 0 ;
+    int argvi = 0;
+    char *result = 0 ;
+    dXSARGS;
+    
+    if ((items < 2) || (items > 2)) {
+      SWIG_croak("Usage: abac_keyid_map_expand_nickname(m,s);");
+    }
+    res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_abac_keyid_map_t, 0 |  0 );
+    if (!SWIG_IsOK(res1)) {
+      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "abac_keyid_map_expand_nickname" "', argument " "1"" of type '" "abac_keyid_map_t *""'"); 
+    }
+    arg1 = reinterpret_cast< abac_keyid_map_t * >(argp1);
+    res2 = SWIG_AsCharPtrAndSize(ST(1), &buf2, NULL, &alloc2);
+    if (!SWIG_IsOK(res2)) {
+      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "abac_keyid_map_expand_nickname" "', argument " "2"" of type '" "char *""'");
+    }
+    arg2 = reinterpret_cast< char * >(buf2);
+    {
+      try {
+        result = (char *)abac_keyid_map_expand_nickname(arg1,arg2);
+      }
+      catch (std::invalid_argument) {
+        croak("std::invalid_argument");
+      }
+      catch (std::logic_error) {
+        croak("std::logic_error");
+      }
+    }
+    ST(argvi) = SWIG_FromCharPtr((const char *)result); argvi++ ;
+    
+    if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
+    XSRETURN(argvi);
+  fail:
+    
+    if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
+    SWIG_croak_null();
+  }
+}
+
+
+XS(_wrap_new_Context__SWIG_0) {
+  {
+    int argvi = 0;
+    ABAC::Context *result = 0 ;
+    dXSARGS;
+    
+    if ((items < 0) || (items > 0)) {
+      SWIG_croak("Usage: new_Context();");
+    }
+    {
+      try {
+        result = (ABAC::Context *)new ABAC::Context();
+      }
+      catch (std::invalid_argument) {
+        croak("std::invalid_argument");
+      }
+      catch (std::logic_error) {
+        croak("std::logic_error");
+      }
+    }
+    ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ABAC__Context, SWIG_OWNER | SWIG_SHADOW); argvi++ ;
+    XSRETURN(argvi);
+  fail:
+    SWIG_croak_null();
+  }
+}
+
+
+XS(_wrap_new_Context__SWIG_1) {
+  {
+    ABAC::Context *arg1 = 0 ;
+    void *argp1 ;
+    int res1 = 0 ;
+    int argvi = 0;
+    ABAC::Context *result = 0 ;
+    dXSARGS;
+    
+    if ((items < 1) || (items > 1)) {
+      SWIG_croak("Usage: new_Context(context);");
+    }
+    res1 = SWIG_ConvertPtr(ST(0), &argp1, SWIGTYPE_p_ABAC__Context,  0 );
+    if (!SWIG_IsOK(res1)) {
+      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Context" "', argument " "1"" of type '" "ABAC::Context const &""'"); 
+    }
+    if (!argp1) {
+      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Context" "', argument " "1"" of type '" "ABAC::Context const &""'"); 
+    }
+    arg1 = reinterpret_cast< ABAC::Context * >(argp1);
+    {
+      try {
+        result = (ABAC::Context *)new ABAC::Context((ABAC::Context const &)*arg1);
+      }
+      catch (std::invalid_argument) {
+        croak("std::invalid_argument");
+      }
+      catch (std::logic_error) {
+        croak("std::logic_error");
+      }
+    }
+    ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ABAC__Context, SWIG_OWNER | SWIG_SHADOW); argvi++ ;
+    
+    XSRETURN(argvi);
+  fail:
+    
+    SWIG_croak_null();
+  }
+}
+
+
+XS(_wrap_new_Context) {
+  dXSARGS;
+  
+  {
+    unsigned long _index = 0;
+    SWIG_TypeRank _rank = 0; 
+    if (items == 0) {
+      SWIG_TypeRank _ranki = 0;
+      SWIG_TypeRank _rankm = 0;
+      if (!_index || (_ranki < _rank)) {
+        _rank = _ranki; _index = 1;
+        if (_rank == _rankm) goto dispatch;
+      }
+    }
+    if (items == 1) {
+      SWIG_TypeRank _ranki = 0;
+      SWIG_TypeRank _rankm = 0;
+      SWIG_TypeRank _pi = 1;
+      int _v = 0;
+      {
+        void *vptr = 0;
+        int res = SWIG_ConvertPtr(ST(0), &vptr, SWIGTYPE_p_ABAC__Context, 0);
+        _v = SWIG_CheckState(res);
+      }
+      if (!_v) goto check_2;
+      _ranki += _v*_pi;
+      _rankm += _pi;
+      _pi *= SWIG_MAXCASTRANK;
+      if (!_index || (_ranki < _rank)) {
+        _rank = _ranki; _index = 2;
+        if (_rank == _rankm) goto dispatch;
+      }
+    }
+  check_2:
+    
+  dispatch:
+    switch(_index) {
+    case 1:
+      PUSHMARK(MARK); SWIG_CALLXS(_wrap_new_Context__SWIG_0); return;
+    case 2:
+      PUSHMARK(MARK); SWIG_CALLXS(_wrap_new_Context__SWIG_1); return;
+    }
+  }
+  
+  croak("No matching function for overloaded 'new_Context'");
+  XSRETURN(0);
+}
+
+
+XS(_wrap_delete_Context) {
+  {
+    ABAC::Context *arg1 = (ABAC::Context *) 0 ;
+    void *argp1 = 0 ;
+    int res1 = 0 ;
+    int argvi = 0;
+    dXSARGS;
+    
+    if ((items < 1) || (items > 1)) {
+      SWIG_croak("Usage: delete_Context(self);");
+    }
+    res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_ABAC__Context, SWIG_POINTER_DISOWN |  0 );
+    if (!SWIG_IsOK(res1)) {
+      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Context" "', argument " "1"" of type '" "ABAC::Context *""'"); 
+    }
+    arg1 = reinterpret_cast< ABAC::Context * >(argp1);
+    {
+      try {
+        delete arg1;
+      }
+      catch (std::invalid_argument) {
+        croak("std::invalid_argument");
+      }
+      catch (std::logic_error) {
+        croak("std::logic_error");
+      }
+    }
+    ST(argvi) = sv_newmortal();
+    
+    XSRETURN(argvi);
+  fail:
+    
+    SWIG_croak_null();
+  }
+}
+
+
+XS(_wrap_Context_load_id_file) {
+  {
+    ABAC::Context *arg1 = (ABAC::Context *) 0 ;
+    char *arg2 = (char *) 0 ;
+    void *argp1 = 0 ;
+    int res1 = 0 ;
+    int res2 ;
+    char *buf2 = 0 ;
+    int alloc2 = 0 ;
+    int argvi = 0;
+    int result;
+    dXSARGS;
+    
+    if ((items < 2) || (items > 2)) {
+      SWIG_croak("Usage: Context_load_id_file(self,filename);");
+    }
+    res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_ABAC__Context, 0 |  0 );
+    if (!SWIG_IsOK(res1)) {
+      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Context_load_id_file" "', argument " "1"" of type '" "ABAC::Context *""'"); 
+    }
+    arg1 = reinterpret_cast< ABAC::Context * >(argp1);
+    res2 = SWIG_AsCharPtrAndSize(ST(1), &buf2, NULL, &alloc2);
+    if (!SWIG_IsOK(res2)) {
+      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Context_load_id_file" "', argument " "2"" of type '" "char *""'");
+    }
+    arg2 = reinterpret_cast< char * >(buf2);
+    {
+      try {
+        result = (int)(arg1)->load_id_file(arg2);
+      }
+      catch (std::invalid_argument) {
+        croak("std::invalid_argument");
+      }
+      catch (std::logic_error) {
+        croak("std::logic_error");
+      }
+    }
+    ST(argvi) = SWIG_From_int  SWIG_PERL_CALL_ARGS_1(static_cast< int >(result)); argvi++ ;
+    
+    if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
+    XSRETURN(argvi);
+  fail:
+    
+    if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
+    SWIG_croak_null();
+  }
+}
+
+
+XS(_wrap_Context_load_id_chunk) {
+  {
+    ABAC::Context *arg1 = (ABAC::Context *) 0 ;
+    abac_chunk_t arg2 ;
+    void *argp1 = 0 ;
+    int res1 = 0 ;
+    int argvi = 0;
+    int result;
+    dXSARGS;
+    
+    if ((items < 2) || (items > 2)) {
+      SWIG_croak("Usage: Context_load_id_chunk(self,cert);");
+    }
+    res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_ABAC__Context, 0 |  0 );
+    if (!SWIG_IsOK(res1)) {
+      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Context_load_id_chunk" "', argument " "1"" of type '" "ABAC::Context *""'"); 
+    }
+    arg1 = reinterpret_cast< ABAC::Context * >(argp1);
+    {
+      STRLEN len;
+      (&arg2)->ptr = (unsigned char *)SvPV(ST(1), len);
+      (&arg2)->len = len;
+    }
+    {
+      try {
+        result = (int)(arg1)->load_id_chunk(arg2);
+      }
+      catch (std::invalid_argument) {
+        croak("std::invalid_argument");
+      }
+      catch (std::logic_error) {
+        croak("std::logic_error");
+      }
+    }
+    ST(argvi) = SWIG_From_int  SWIG_PERL_CALL_ARGS_1(static_cast< int >(result)); argvi++ ;
+    
+    XSRETURN(argvi);
+  fail:
+    
+    SWIG_croak_null();
+  }
+}
+
+
+XS(_wrap_Context_load_id_id) {
+  {
+    ABAC::Context *arg1 = (ABAC::Context *) 0 ;
+    ABAC::ID *arg2 = 0 ;
+    void *argp1 = 0 ;
+    int res1 = 0 ;
+    void *argp2 = 0 ;
+    int res2 = 0 ;
+    int argvi = 0;
+    int result;
+    dXSARGS;
+    
+    if ((items < 2) || (items > 2)) {
+      SWIG_croak("Usage: Context_load_id_id(self,id);");
+    }
+    res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_ABAC__Context, 0 |  0 );
+    if (!SWIG_IsOK(res1)) {
+      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Context_load_id_id" "', argument " "1"" of type '" "ABAC::Context *""'"); 
+    }
+    arg1 = reinterpret_cast< ABAC::Context * >(argp1);
+    res2 = SWIG_ConvertPtr(ST(1), &argp2, SWIGTYPE_p_ABAC__ID,  0 );
+    if (!SWIG_IsOK(res2)) {
+      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Context_load_id_id" "', argument " "2"" of type '" "ABAC::ID &""'"); 
+    }
+    if (!argp2) {
+      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Context_load_id_id" "', argument " "2"" of type '" "ABAC::ID &""'"); 
+    }
+    arg2 = reinterpret_cast< ABAC::ID * >(argp2);
+    {
+      try {
+        result = (int)(arg1)->load_id_id(*arg2);
+      }
+      catch (std::invalid_argument) {
+        croak("std::invalid_argument");
+      }
+      catch (std::logic_error) {
+        croak("std::logic_error");
+      }
+    }
+    ST(argvi) = SWIG_From_int  SWIG_PERL_CALL_ARGS_1(static_cast< int >(result)); argvi++ ;
+    
+    
+    XSRETURN(argvi);
+  fail:
+    
+    
+    SWIG_croak_null();
+  }
+}
+
+
+XS(_wrap_Context_load_attribute_file) {
+  {
+    ABAC::Context *arg1 = (ABAC::Context *) 0 ;
+    char *arg2 = (char *) 0 ;
+    void *argp1 = 0 ;
+    int res1 = 0 ;
+    int res2 ;
+    char *buf2 = 0 ;
+    int alloc2 = 0 ;
+    int argvi = 0;
+    int result;
+    dXSARGS;
+    
+    if ((items < 2) || (items > 2)) {
+      SWIG_croak("Usage: Context_load_attribute_file(self,filename);");
+    }
+    res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_ABAC__Context, 0 |  0 );
+    if (!SWIG_IsOK(res1)) {
+      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Context_load_attribute_file" "', argument " "1"" of type '" "ABAC::Context *""'"); 
+    }
+    arg1 = reinterpret_cast< ABAC::Context * >(argp1);
+    res2 = SWIG_AsCharPtrAndSize(ST(1), &buf2, NULL, &alloc2);
+    if (!SWIG_IsOK(res2)) {
+      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Context_load_attribute_file" "', argument " "2"" of type '" "char *""'");
+    }
+    arg2 = reinterpret_cast< char * >(buf2);
+    {
+      try {
+        result = (int)(arg1)->load_attribute_file(arg2);
+      }
+      catch (std::invalid_argument) {
+        croak("std::invalid_argument");
+      }
+      catch (std::logic_error) {
+        croak("std::logic_error");
+      }
+    }
+    ST(argvi) = SWIG_From_int  SWIG_PERL_CALL_ARGS_1(static_cast< int >(result)); argvi++ ;
+    
+    if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
+    XSRETURN(argvi);
+  fail:
+    
+    if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
+    SWIG_croak_null();
+  }
+}
+
+
+XS(_wrap_Context_load_attribute_chunk) {
+  {
+    ABAC::Context *arg1 = (ABAC::Context *) 0 ;
+    abac_chunk_t arg2 ;
+    void *argp1 = 0 ;
+    int res1 = 0 ;
+    int argvi = 0;
+    int result;
+    dXSARGS;
+    
+    if ((items < 2) || (items > 2)) {
+      SWIG_croak("Usage: Context_load_attribute_chunk(self,cert);");
+    }
+    res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_ABAC__Context, 0 |  0 );
+    if (!SWIG_IsOK(res1)) {
+      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Context_load_attribute_chunk" "', argument " "1"" of type '" "ABAC::Context *""'"); 
+    }
+    arg1 = reinterpret_cast< ABAC::Context * >(argp1);
+    {
+      STRLEN len;
+      (&arg2)->ptr = (unsigned char *)SvPV(ST(1), len);
+      (&arg2)->len = len;
+    }
+    {
+      try {
+        result = (int)(arg1)->load_attribute_chunk(arg2);
+      }
+      catch (std::invalid_argument) {
+        croak("std::invalid_argument");
+      }
+      catch (std::logic_error) {
+        croak("std::logic_error");
+      }
+    }
+    ST(argvi) = SWIG_From_int  SWIG_PERL_CALL_ARGS_1(static_cast< int >(result)); argvi++ ;
+    
+    XSRETURN(argvi);
+  fail:
+    
+    SWIG_croak_null();
+  }
+}
+
+
+XS(_wrap_Context_query) {
+  {
+    ABAC::Context *arg1 = (ABAC::Context *) 0 ;
+    char *arg2 = (char *) 0 ;
+    char *arg3 = (char *) 0 ;
+    bool *arg4 = 0 ;
+    void *argp1 = 0 ;
+    int res1 = 0 ;
+    int res2 ;
+    char *buf2 = 0 ;
+    int alloc2 = 0 ;
+    int res3 ;
+    char *buf3 = 0 ;
+    int alloc3 = 0 ;
+    bool temp4 ;
+    int argvi = 0;
+    std::vector< ABAC::Credential > result;
+    dXSARGS;
+    
+    {
+      arg4 = &temp4;
+    }
+    if ((items < 3) || (items > 3)) {
+      SWIG_croak("Usage: Context_query(self,role,principal);");
+    }
+    res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_ABAC__Context, 0 |  0 );
+    if (!SWIG_IsOK(res1)) {
+      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Context_query" "', argument " "1"" of type '" "ABAC::Context *""'"); 
+    }
+    arg1 = reinterpret_cast< ABAC::Context * >(argp1);
+    res2 = SWIG_AsCharPtrAndSize(ST(1), &buf2, NULL, &alloc2);
+    if (!SWIG_IsOK(res2)) {
+      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Context_query" "', argument " "2"" of type '" "char *""'");
+    }
+    arg2 = reinterpret_cast< char * >(buf2);
+    res3 = SWIG_AsCharPtrAndSize(ST(2), &buf3, NULL, &alloc3);
+    if (!SWIG_IsOK(res3)) {
+      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Context_query" "', argument " "3"" of type '" "char *""'");
+    }
+    arg3 = reinterpret_cast< char * >(buf3);
+    {
+      try {
+        result = (arg1)->query(arg2,arg3,*arg4);
+      }
+      catch (std::invalid_argument) {
+        croak("std::invalid_argument");
+      }
+      catch (std::logic_error) {
+        croak("std::logic_error");
+      }
+    }
+    {
+      size_t len = (&result)->size();
+      SV **svs = new SV*[len];
+      for (size_t i=0; i<len; i++) {
+        ABAC::Credential* ptr = new ABAC::Credential(result[i]);
+        svs[i] = sv_newmortal();
+        SWIG_MakePtr(svs[i], (void*) ptr, 
+          SWIGTYPE_p_ABAC__Credential, SWIG_SHADOW|0);
+      }
+      AV *myav = av_make(len, svs);
+      delete[] svs;
+      ST(argvi) = newRV_noinc((SV*) myav);
+      sv_2mortal(ST(argvi));
+      argvi++;
+    }
+    {
+      --argvi;
+      SV *array = ST(argvi);
+      
+      ST(argvi) = sv_newmortal();
+      sv_setiv(ST(argvi), *arg4);
+      ++argvi;
+      
+      ST(argvi) = array;
+      ++argvi;
+    }
+    
+    if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
+    if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
+    
+    XSRETURN(argvi);
+  fail:
+    
+    if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
+    if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
+    
+    SWIG_croak_null();
+  }
+}
+
+
+XS(_wrap_Context_credentials) {
+  {
+    ABAC::Context *arg1 = (ABAC::Context *) 0 ;
+    void *argp1 = 0 ;
+    int res1 = 0 ;
+    int argvi = 0;
+    std::vector< ABAC::Credential > result;
+    dXSARGS;
+    
+    if ((items < 1) || (items > 1)) {
+      SWIG_croak("Usage: Context_credentials(self);");
+    }
+    res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_ABAC__Context, 0 |  0 );
+    if (!SWIG_IsOK(res1)) {
+      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Context_credentials" "', argument " "1"" of type '" "ABAC::Context *""'"); 
+    }
+    arg1 = reinterpret_cast< ABAC::Context * >(argp1);
+    {
+      try {
+        result = (arg1)->credentials();
+      }
+      catch (std::invalid_argument) {
+        croak("std::invalid_argument");
+      }
+      catch (std::logic_error) {
+        croak("std::logic_error");
+      }
+    }
+    {
+      size_t len = (&result)->size();
+      SV **svs = new SV*[len];
+      for (size_t i=0; i<len; i++) {
+        ABAC::Credential* ptr = new ABAC::Credential(result[i]);
+        svs[i] = sv_newmortal();
+        SWIG_MakePtr(svs[i], (void*) ptr, 
+          SWIGTYPE_p_ABAC__Credential, SWIG_SHADOW|0);
+      }
+      AV *myav = av_make(len, svs);
+      delete[] svs;
+      ST(argvi) = newRV_noinc((SV*) myav);
+      sv_2mortal(ST(argvi));
+      argvi++;
+    }
+    
+    XSRETURN(argvi);
+  fail:
+    
+    SWIG_croak_null();
+  }
+}
+
+
+XS(_wrap_Context_load_directory) {
+  {
+    ABAC::Context *arg1 = (ABAC::Context *) 0 ;
+    char *arg2 = (char *) 0 ;
+    void *argp1 = 0 ;
+    int res1 = 0 ;
+    int res2 ;
+    char *buf2 = 0 ;
+    int alloc2 = 0 ;
+    int argvi = 0;
+    dXSARGS;
+    
+    if ((items < 2) || (items > 2)) {
+      SWIG_croak("Usage: Context_load_directory(self,path);");
+    }
+    res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_ABAC__Context, 0 |  0 );
+    if (!SWIG_IsOK(res1)) {
+      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Context_load_directory" "', argument " "1"" of type '" "ABAC::Context *""'"); 
+    }
+    arg1 = reinterpret_cast< ABAC::Context * >(argp1);
+    res2 = SWIG_AsCharPtrAndSize(ST(1), &buf2, NULL, &alloc2);
+    if (!SWIG_IsOK(res2)) {
+      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Context_load_directory" "', argument " "2"" of type '" "char *""'");
+    }
+    arg2 = reinterpret_cast< char * >(buf2);
+    {
+      try {
+        (arg1)->load_directory(arg2);
+      }
+      catch (std::invalid_argument) {
+        croak("std::invalid_argument");
+      }
+      catch (std::logic_error) {
+        croak("std::logic_error");
+      }
+    }
+    ST(argvi) = sv_newmortal();
+    
+    if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
+    XSRETURN(argvi);
+  fail:
+    
+    if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
+    SWIG_croak_null();
+  }
+}
+
+
+XS(_wrap_Context_set_nickname) {
+  {
+    ABAC::Context *arg1 = (ABAC::Context *) 0 ;
+    char *arg2 = (char *) 0 ;
+    char *arg3 = (char *) 0 ;
+    void *argp1 = 0 ;
+    int res1 = 0 ;
+    int res2 ;
+    char *buf2 = 0 ;
+    int alloc2 = 0 ;
+    int res3 ;
+    char *buf3 = 0 ;
+    int alloc3 = 0 ;
+    int argvi = 0;
+    dXSARGS;
+    
+    if ((items < 3) || (items > 3)) {
+      SWIG_croak("Usage: Context_set_nickname(self,key,nick);");
+    }
+    res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_ABAC__Context, 0 |  0 );
+    if (!SWIG_IsOK(res1)) {
+      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Context_set_nickname" "', argument " "1"" of type '" "ABAC::Context *""'"); 
+    }
+    arg1 = reinterpret_cast< ABAC::Context * >(argp1);
+    res2 = SWIG_AsCharPtrAndSize(ST(1), &buf2, NULL, &alloc2);
+    if (!SWIG_IsOK(res2)) {
+      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Context_set_nickname" "', argument " "2"" of type '" "char *""'");
+    }
+    arg2 = reinterpret_cast< char * >(buf2);
+    res3 = SWIG_AsCharPtrAndSize(ST(2), &buf3, NULL, &alloc3);
+    if (!SWIG_IsOK(res3)) {
+      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Context_set_nickname" "', argument " "3"" of type '" "char *""'");
+    }
+    arg3 = reinterpret_cast< char * >(buf3);
+    {
+      try {
+        (arg1)->set_nickname(arg2,arg3);
+      }
+      catch (std::invalid_argument) {
+        croak("std::invalid_argument");
+      }
+      catch (std::logic_error) {
+        croak("std::logic_error");
+      }
+    }
+    ST(argvi) = sv_newmortal();
+    
+    if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
+    if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
+    XSRETURN(argvi);
+  fail:
+    
+    if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
+    if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
+    SWIG_croak_null();
+  }
+}
+
+
+XS(_wrap_new_Role__SWIG_0) {
+  {
+    int argvi = 0;
+    ABAC::Role *result = 0 ;
+    dXSARGS;
+    
+    if ((items < 0) || (items > 0)) {
+      SWIG_croak("Usage: new_Role();");
+    }
+    {
+      try {
+        result = (ABAC::Role *)new ABAC::Role();
+      }
+      catch (std::invalid_argument) {
+        croak("std::invalid_argument");
+      }
+      catch (std::logic_error) {
+        croak("std::logic_error");
+      }
+    }
+    ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ABAC__Role, SWIG_OWNER | SWIG_SHADOW); argvi++ ;
+    XSRETURN(argvi);
+  fail:
+    SWIG_croak_null();
+  }
+}
+
+
+XS(_wrap_new_Role__SWIG_1) {
+  {
+    abac_role_t *arg1 = (abac_role_t *) 0 ;
+    void *argp1 = 0 ;
+    int res1 = 0 ;
+    int argvi = 0;
+    ABAC::Role *result = 0 ;
+    dXSARGS;
+    
+    if ((items < 1) || (items > 1)) {
+      SWIG_croak("Usage: new_Role(role);");
+    }
+    res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p__abac_role_t, 0 |  0 );
+    if (!SWIG_IsOK(res1)) {
+      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Role" "', argument " "1"" of type '" "abac_role_t *""'"); 
+    }
+    arg1 = reinterpret_cast< abac_role_t * >(argp1);
+    {
+      try {
+        result = (ABAC::Role *)new ABAC::Role(arg1);
+      }
+      catch (std::invalid_argument) {
+        croak("std::invalid_argument");
+      }
+      catch (std::logic_error) {
+        croak("std::logic_error");
+      }
+    }
+    ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ABAC__Role, SWIG_OWNER | SWIG_SHADOW); argvi++ ;
+    
+    XSRETURN(argvi);
+  fail:
+    
+    SWIG_croak_null();
+  }
+}
+
+
+XS(_wrap_new_Role__SWIG_2) {
+  {
+    char *arg1 = (char *) 0 ;
+    int res1 ;
+    char *buf1 = 0 ;
+    int alloc1 = 0 ;
+    int argvi = 0;
+    ABAC::Role *result = 0 ;
+    dXSARGS;
+    
+    if ((items < 1) || (items > 1)) {
+      SWIG_croak("Usage: new_Role(role_name);");
+    }
+    res1 = SWIG_AsCharPtrAndSize(ST(0), &buf1, NULL, &alloc1);
+    if (!SWIG_IsOK(res1)) {
+      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Role" "', argument " "1"" of type '" "char *""'");
+    }
+    arg1 = reinterpret_cast< char * >(buf1);
+    {
+      try {
+        result = (ABAC::Role *)new ABAC::Role(arg1);
+      }
+      catch (std::invalid_argument) {
+        croak("std::invalid_argument");
+      }
+      catch (std::logic_error) {
+        croak("std::logic_error");
+      }
+    }
+    ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ABAC__Role, SWIG_OWNER | SWIG_SHADOW); argvi++ ;
+    if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
+    XSRETURN(argvi);
+  fail:
+    if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
+    SWIG_croak_null();
+  }
+}
+
+
+XS(_wrap_new_Role__SWIG_3) {
+  {
+    ABAC::Role *arg1 = 0 ;
+    void *argp1 ;
+    int res1 = 0 ;
+    int argvi = 0;
+    ABAC::Role *result = 0 ;
+    dXSARGS;
+    
+    if ((items < 1) || (items > 1)) {
+      SWIG_croak("Usage: new_Role(role);");
+    }
+    res1 = SWIG_ConvertPtr(ST(0), &argp1, SWIGTYPE_p_ABAC__Role,  0 );
+    if (!SWIG_IsOK(res1)) {
+      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Role" "', argument " "1"" of type '" "ABAC::Role const &""'"); 
+    }
+    if (!argp1) {
+      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Role" "', argument " "1"" of type '" "ABAC::Role const &""'"); 
+    }
+    arg1 = reinterpret_cast< ABAC::Role * >(argp1);
+    {
+      try {
+        result = (ABAC::Role *)new ABAC::Role((ABAC::Role const &)*arg1);
+      }
+      catch (std::invalid_argument) {
+        croak("std::invalid_argument");
+      }
+      catch (std::logic_error) {
+        croak("std::logic_error");
+      }
+    }
+    ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ABAC__Role, SWIG_OWNER | SWIG_SHADOW); argvi++ ;
+    
+    XSRETURN(argvi);
+  fail:
+    
+    SWIG_croak_null();
+  }
+}
+
+
+XS(_wrap_new_Role) {
+  dXSARGS;
+  
+  {
+    unsigned long _index = 0;
+    SWIG_TypeRank _rank = 0; 
+    if (items == 0) {
+      SWIG_TypeRank _ranki = 0;
+      SWIG_TypeRank _rankm = 0;
+      if (!_index || (_ranki < _rank)) {
+        _rank = _ranki; _index = 1;
+        if (_rank == _rankm) goto dispatch;
+      }
+    }
+    if (items == 1) {
+      SWIG_TypeRank _ranki = 0;
+      SWIG_TypeRank _rankm = 0;
+      SWIG_TypeRank _pi = 1;
+      int _v = 0;
+      {
+        void *vptr = 0;
+        int res = SWIG_ConvertPtr(ST(0), &vptr, SWIGTYPE_p__abac_role_t, 0);
+        _v = SWIG_CheckState(res);
+      }
+      if (!_v) goto check_2;
+      _ranki += _v*_pi;
+      _rankm += _pi;
+      _pi *= SWIG_MAXCASTRANK;
+      if (!_index || (_ranki < _rank)) {
+        _rank = _ranki; _index = 2;
+        if (_rank == _rankm) goto dispatch;
+      }
+    }
+  check_2:
+    
+    if (items == 1) {
+      SWIG_TypeRank _ranki = 0;
+      SWIG_TypeRank _rankm = 0;
+      SWIG_TypeRank _pi = 1;
+      int _v = 0;
+      {
+        void *vptr = 0;
+        int res = SWIG_ConvertPtr(ST(0), &vptr, SWIGTYPE_p_ABAC__Role, 0);
+        _v = SWIG_CheckState(res);
+      }
+      if (!_v) goto check_3;
+      _ranki += _v*_pi;
+      _rankm += _pi;
+      _pi *= SWIG_MAXCASTRANK;
+      if (!_index || (_ranki < _rank)) {
+        _rank = _ranki; _index = 3;
+        if (_rank == _rankm) goto dispatch;
+      }
+    }
+  check_3:
+    
+    if (items == 1) {
+      SWIG_TypeRank _ranki = 0;
+      SWIG_TypeRank _rankm = 0;
+      SWIG_TypeRank _pi = 1;
+      int _v = 0;
+      {
+        int res = SWIG_AsCharPtrAndSize(ST(0), 0, NULL, 0);
+        _v = SWIG_CheckState(res);
+      }
+      if (!_v) goto check_4;
+      _ranki += _v*_pi;
+      _rankm += _pi;
+      _pi *= SWIG_MAXCASTRANK;
+      if (!_index || (_ranki < _rank)) {
+        _rank = _ranki; _index = 4;
+        if (_rank == _rankm) goto dispatch;
+      }
+    }
+  check_4:
+    
+  dispatch:
+    switch(_index) {
+    case 1:
+      PUSHMARK(MARK); SWIG_CALLXS(_wrap_new_Role__SWIG_0); return;
+    case 2:
+      PUSHMARK(MARK); SWIG_CALLXS(_wrap_new_Role__SWIG_1); return;
+    case 3:
+      PUSHMARK(MARK); SWIG_CALLXS(_wrap_new_Role__SWIG_3); return;
+    case 4:
+      PUSHMARK(MARK); SWIG_CALLXS(_wrap_new_Role__SWIG_2); return;
+    }
+  }
+  
+  croak("No matching function for overloaded 'new_Role'");
+  XSRETURN(0);
+}
+
+
+XS(_wrap_delete_Role) {
+  {
+    ABAC::Role *arg1 = (ABAC::Role *) 0 ;
+    void *argp1 = 0 ;
+    int res1 = 0 ;
+    int argvi = 0;
+    dXSARGS;
+    
+    if ((items < 1) || (items > 1)) {
+      SWIG_croak("Usage: delete_Role(self);");
+    }
+    res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_ABAC__Role, SWIG_POINTER_DISOWN |  0 );
+    if (!SWIG_IsOK(res1)) {
+      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Role" "', argument " "1"" of type '" "ABAC::Role *""'"); 
+    }
+    arg1 = reinterpret_cast< ABAC::Role * >(argp1);
+    {
+      try {
+        delete arg1;
+      }
+      catch (std::invalid_argument) {
+        croak("std::invalid_argument");
+      }
+      catch (std::logic_error) {
+        croak("std::logic_error");
+      }
+    }
+    ST(argvi) = sv_newmortal();
+    
+    XSRETURN(argvi);
+  fail:
+    
+    SWIG_croak_null();
+  }
+}
+
+
+XS(_wrap_Role_is_principal) {
+  {
+    ABAC::Role *arg1 = (ABAC::Role *) 0 ;
+    void *argp1 = 0 ;
+    int res1 = 0 ;
+    int argvi = 0;
+    bool result;
+    dXSARGS;
+    
+    if ((items < 1) || (items > 1)) {
+      SWIG_croak("Usage: Role_is_principal(self);");
+    }
+    res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_ABAC__Role, 0 |  0 );
+    if (!SWIG_IsOK(res1)) {
+      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Role_is_principal" "', argument " "1"" of type '" "ABAC::Role const *""'"); 
+    }
+    arg1 = reinterpret_cast< ABAC::Role * >(argp1);
+    {
+      try {
+        result = (bool)((ABAC::Role const *)arg1)->is_principal();
+      }
+      catch (std::invalid_argument) {
+        croak("std::invalid_argument");
+      }
+      catch (std::logic_error) {
+        croak("std::logic_error");
+      }
+    }
+    ST(argvi) = SWIG_From_bool  SWIG_PERL_CALL_ARGS_1(static_cast< bool >(result)); argvi++ ;
+    
+    XSRETURN(argvi);
+  fail:
+    
+    SWIG_croak_null();
+  }
+}
+
+
+XS(_wrap_Role_is_role) {
+  {
+    ABAC::Role *arg1 = (ABAC::Role *) 0 ;
+    void *argp1 = 0 ;
+    int res1 = 0 ;
+    int argvi = 0;
+    bool result;
+    dXSARGS;
+    
+    if ((items < 1) || (items > 1)) {
+      SWIG_croak("Usage: Role_is_role(self);");
+    }
+    res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_ABAC__Role, 0 |  0 );
+    if (!SWIG_IsOK(res1)) {
+      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Role_is_role" "', argument " "1"" of type '" "ABAC::Role const *""'"); 
+    }
+    arg1 = reinterpret_cast< ABAC::Role * >(argp1);
+    {
+      try {
+        result = (bool)((ABAC::Role const *)arg1)->is_role();
+      }
+      catch (std::invalid_argument) {
+        croak("std::invalid_argument");
+      }
+      catch (std::logic_error) {
+        croak("std::logic_error");
+      }
+    }
+    ST(argvi) = SWIG_From_bool  SWIG_PERL_CALL_ARGS_1(static_cast< bool >(result)); argvi++ ;
+    
+    XSRETURN(argvi);
+  fail:
+    
+    SWIG_croak_null();
+  }
+}
+
+
+XS(_wrap_Role_is_linking) {
+  {
+    ABAC::Role *arg1 = (ABAC::Role *) 0 ;
+    void *argp1 = 0 ;
+    int res1 = 0 ;
+    int argvi = 0;
+    bool result;
+    dXSARGS;
+    
+    if ((items < 1) || (items > 1)) {
+      SWIG_croak("Usage: Role_is_linking(self);");
+    }
+    res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_ABAC__Role, 0 |  0 );
+    if (!SWIG_IsOK(res1)) {
+      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Role_is_linking" "', argument " "1"" of type '" "ABAC::Role const *""'"); 
+    }
+    arg1 = reinterpret_cast< ABAC::Role * >(argp1);
+    {
+      try {
+        result = (bool)((ABAC::Role const *)arg1)->is_linking();
+      }
+      catch (std::invalid_argument) {
+        croak("std::invalid_argument");
+      }
+      catch (std::logic_error) {
+        croak("std::logic_error");
+      }
+    }
+    ST(argvi) = SWIG_From_bool  SWIG_PERL_CALL_ARGS_1(static_cast< bool >(result)); argvi++ ;
+    
+    XSRETURN(argvi);
+  fail:
+    
+    SWIG_croak_null();
+  }
+}
+
+
+XS(_wrap_Role_string) {
+  {
+    ABAC::Role *arg1 = (ABAC::Role *) 0 ;
+    void *argp1 = 0 ;
+    int res1 = 0 ;
+    int argvi = 0;
+    char *result = 0 ;
+    dXSARGS;
+    
+    if ((items < 1) || (items > 1)) {
+      SWIG_croak("Usage: Role_string(self);");
+    }
+    res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_ABAC__Role, 0 |  0 );
+    if (!SWIG_IsOK(res1)) {
+      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Role_string" "', argument " "1"" of type '" "ABAC::Role const *""'"); 
+    }
+    arg1 = reinterpret_cast< ABAC::Role * >(argp1);
+    {
+      try {
+        result = (char *)((ABAC::Role const *)arg1)->string();
+      }
+      catch (std::invalid_argument) {
+        croak("std::invalid_argument");
+      }
+      catch (std::logic_error) {
+        croak("std::logic_error");
+      }
+    }
+    ST(argvi) = SWIG_FromCharPtr((const char *)result); argvi++ ;
+    
+    XSRETURN(argvi);
+  fail:
+    
+    SWIG_croak_null();
+  }
+}
+
+
+XS(_wrap_Role_short_string) {
+  {
+    ABAC::Role *arg1 = (ABAC::Role *) 0 ;
+    ABAC::Context *arg2 = 0 ;
+    void *argp1 = 0 ;
+    int res1 = 0 ;
+    void *argp2 = 0 ;
+    int res2 = 0 ;
+    int argvi = 0;
+    char *result = 0 ;
+    dXSARGS;
+    
+    if ((items < 2) || (items > 2)) {
+      SWIG_croak("Usage: Role_short_string(self,c);");
+    }
+    res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_ABAC__Role, 0 |  0 );
+    if (!SWIG_IsOK(res1)) {
+      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Role_short_string" "', argument " "1"" of type '" "ABAC::Role const *""'"); 
+    }
+    arg1 = reinterpret_cast< ABAC::Role * >(argp1);
+    res2 = SWIG_ConvertPtr(ST(1), &argp2, SWIGTYPE_p_ABAC__Context,  0 );
+    if (!SWIG_IsOK(res2)) {
+      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Role_short_string" "', argument " "2"" of type '" "ABAC::Context &""'"); 
+    }
+    if (!argp2) {
+      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Role_short_string" "', argument " "2"" of type '" "ABAC::Context &""'"); 
+    }
+    arg2 = reinterpret_cast< ABAC::Context * >(argp2);
+    {
+      try {
+        result = (char *)((ABAC::Role const *)arg1)->short_string(*arg2);
+      }
+      catch (std::invalid_argument) {
+        croak("std::invalid_argument");
+      }
+      catch (std::logic_error) {
+        croak("std::logic_error");
+      }
+    }
+    ST(argvi) = SWIG_FromCharPtr((const char *)result); argvi++ ;
+    
+    
+    XSRETURN(argvi);
+  fail:
+    
+    
+    SWIG_croak_null();
+  }
+}
+
+
+XS(_wrap_Role_linked_role) {
+  {
+    ABAC::Role *arg1 = (ABAC::Role *) 0 ;
+    void *argp1 = 0 ;
+    int res1 = 0 ;
+    int argvi = 0;
+    char *result = 0 ;
+    dXSARGS;
+    
+    if ((items < 1) || (items > 1)) {
+      SWIG_croak("Usage: Role_linked_role(self);");
+    }
+    res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_ABAC__Role, 0 |  0 );
+    if (!SWIG_IsOK(res1)) {
+      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Role_linked_role" "', argument " "1"" of type '" "ABAC::Role const *""'"); 
+    }
+    arg1 = reinterpret_cast< ABAC::Role * >(argp1);
+    {
+      try {
+        result = (char *)((ABAC::Role const *)arg1)->linked_role();
+      }
+      catch (std::invalid_argument) {
+        croak("std::invalid_argument");
+      }
+      catch (std::logic_error) {
+        croak("std::logic_error");
+      }
+    }
+    ST(argvi) = SWIG_FromCharPtr((const char *)result); argvi++ ;
+    
+    XSRETURN(argvi);
+  fail:
+    
+    SWIG_croak_null();
+  }
+}
+
+
+XS(_wrap_Role_role_name) {
+  {
+    ABAC::Role *arg1 = (ABAC::Role *) 0 ;
+    void *argp1 = 0 ;
+    int res1 = 0 ;
+    int argvi = 0;
+    char *result = 0 ;
+    dXSARGS;
+    
+    if ((items < 1) || (items > 1)) {
+      SWIG_croak("Usage: Role_role_name(self);");
+    }
+    res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_ABAC__Role, 0 |  0 );
+    if (!SWIG_IsOK(res1)) {
+      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Role_role_name" "', argument " "1"" of type '" "ABAC::Role const *""'"); 
+    }
+    arg1 = reinterpret_cast< ABAC::Role * >(argp1);
+    {
+      try {
+        result = (char *)((ABAC::Role const *)arg1)->role_name();
+      }
+      catch (std::invalid_argument) {
+        croak("std::invalid_argument");
+      }
+      catch (std::logic_error) {
+        croak("std::logic_error");
+      }
+    }
+    ST(argvi) = SWIG_FromCharPtr((const char *)result); argvi++ ;
+    
+    XSRETURN(argvi);
+  fail:
+    
+    SWIG_croak_null();
+  }
+}
+
+
+XS(_wrap_Role_principal) {
+  {
+    ABAC::Role *arg1 = (ABAC::Role *) 0 ;
+    void *argp1 = 0 ;
+    int res1 = 0 ;
+    int argvi = 0;
+    char *result = 0 ;
+    dXSARGS;
+    
+    if ((items < 1) || (items > 1)) {
+      SWIG_croak("Usage: Role_principal(self);");
+    }
+    res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_ABAC__Role, 0 |  0 );
+    if (!SWIG_IsOK(res1)) {
+      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Role_principal" "', argument " "1"" of type '" "ABAC::Role const *""'"); 
+    }
+    arg1 = reinterpret_cast< ABAC::Role * >(argp1);
+    {
+      try {
+        result = (char *)((ABAC::Role const *)arg1)->principal();
+      }
+      catch (std::invalid_argument) {
+        croak("std::invalid_argument");
+      }
+      catch (std::logic_error) {
+        croak("std::logic_error");
+      }
+    }
+    ST(argvi) = SWIG_FromCharPtr((const char *)result); argvi++ ;
+    
+    XSRETURN(argvi);
+  fail:
+    
+    SWIG_croak_null();
+  }
+}
+
+
+XS(_wrap_new_Credential__SWIG_0) {
+  {
+    int argvi = 0;
+    ABAC::Credential *result = 0 ;
+    dXSARGS;
+    
+    if ((items < 0) || (items > 0)) {
+      SWIG_croak("Usage: new_Credential();");
+    }
+    {
+      try {
+        result = (ABAC::Credential *)new ABAC::Credential();
+      }
+      catch (std::invalid_argument) {
+        croak("std::invalid_argument");
+      }
+      catch (std::logic_error) {
+        croak("std::logic_error");
+      }
+    }
+    ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ABAC__Credential, SWIG_OWNER | SWIG_SHADOW); argvi++ ;
+    XSRETURN(argvi);
+  fail:
+    SWIG_croak_null();
+  }
+}
+
+
+XS(_wrap_new_Credential__SWIG_1) {
+  {
+    abac_credential_t *arg1 = (abac_credential_t *) 0 ;
+    void *argp1 = 0 ;
+    int res1 = 0 ;
+    int argvi = 0;
+    ABAC::Credential *result = 0 ;
+    dXSARGS;
+    
+    if ((items < 1) || (items > 1)) {
+      SWIG_croak("Usage: new_Credential(cred);");
+    }
+    res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p__abac_credential_t, 0 |  0 );
+    if (!SWIG_IsOK(res1)) {
+      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Credential" "', argument " "1"" of type '" "abac_credential_t *""'"); 
+    }
+    arg1 = reinterpret_cast< abac_credential_t * >(argp1);
+    {
+      try {
+        result = (ABAC::Credential *)new ABAC::Credential(arg1);
+      }
+      catch (std::invalid_argument) {
+        croak("std::invalid_argument");
+      }
+      catch (std::logic_error) {
+        croak("std::logic_error");
+      }
+    }
+    ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ABAC__Credential, SWIG_OWNER | SWIG_SHADOW); argvi++ ;
+    
+    XSRETURN(argvi);
+  fail:
+    
+    SWIG_croak_null();
+  }
+}
+
+
+XS(_wrap_new_Credential__SWIG_2) {
+  {
+    ABAC::Credential *arg1 = 0 ;
+    void *argp1 ;
+    int res1 = 0 ;
+    int argvi = 0;
+    ABAC::Credential *result = 0 ;
+    dXSARGS;
+    
+    if ((items < 1) || (items > 1)) {
+      SWIG_croak("Usage: new_Credential(cred);");
+    }
+    res1 = SWIG_ConvertPtr(ST(0), &argp1, SWIGTYPE_p_ABAC__Credential,  0 );
+    if (!SWIG_IsOK(res1)) {
+      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Credential" "', argument " "1"" of type '" "ABAC::Credential const &""'"); 
+    }
+    if (!argp1) {
+      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Credential" "', argument " "1"" of type '" "ABAC::Credential const &""'"); 
+    }
+    arg1 = reinterpret_cast< ABAC::Credential * >(argp1);
+    {
+      try {
+        result = (ABAC::Credential *)new ABAC::Credential((ABAC::Credential const &)*arg1);
+      }
+      catch (std::invalid_argument) {
+        croak("std::invalid_argument");
+      }
+      catch (std::logic_error) {
+        croak("std::logic_error");
+      }
+    }
+    ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ABAC__Credential, SWIG_OWNER | SWIG_SHADOW); argvi++ ;
+    
+    XSRETURN(argvi);
+  fail:
+    
+    SWIG_croak_null();
+  }
+}
+
+
+XS(_wrap_new_Credential) {
+  dXSARGS;
+  
+  {
+    unsigned long _index = 0;
+    SWIG_TypeRank _rank = 0; 
+    if (items == 0) {
+      SWIG_TypeRank _ranki = 0;
+      SWIG_TypeRank _rankm = 0;
+      if (!_index || (_ranki < _rank)) {
+        _rank = _ranki; _index = 1;
+        if (_rank == _rankm) goto dispatch;
+      }
+    }
+    if (items == 1) {
+      SWIG_TypeRank _ranki = 0;
+      SWIG_TypeRank _rankm = 0;
+      SWIG_TypeRank _pi = 1;
+      int _v = 0;
+      {
+        void *vptr = 0;
+        int res = SWIG_ConvertPtr(ST(0), &vptr, SWIGTYPE_p__abac_credential_t, 0);
+        _v = SWIG_CheckState(res);
+      }
+      if (!_v) goto check_2;
+      _ranki += _v*_pi;
+      _rankm += _pi;
+      _pi *= SWIG_MAXCASTRANK;
+      if (!_index || (_ranki < _rank)) {
+        _rank = _ranki; _index = 2;
+        if (_rank == _rankm) goto dispatch;
+      }
+    }
+  check_2:
+    
+    if (items == 1) {
+      SWIG_TypeRank _ranki = 0;
+      SWIG_TypeRank _rankm = 0;
+      SWIG_TypeRank _pi = 1;
+      int _v = 0;
+      {
+        void *vptr = 0;
+        int res = SWIG_ConvertPtr(ST(0), &vptr, SWIGTYPE_p_ABAC__Credential, 0);
+        _v = SWIG_CheckState(res);
+      }
+      if (!_v) goto check_3;
+      _ranki += _v*_pi;
+      _rankm += _pi;
+      _pi *= SWIG_MAXCASTRANK;
+      if (!_index || (_ranki < _rank)) {
+        _rank = _ranki; _index = 3;
+        if (_rank == _rankm) goto dispatch;
+      }
+    }
+  check_3:
+    
+  dispatch:
+    switch(_index) {
+    case 1:
+      PUSHMARK(MARK); SWIG_CALLXS(_wrap_new_Credential__SWIG_0); return;
+    case 2:
+      PUSHMARK(MARK); SWIG_CALLXS(_wrap_new_Credential__SWIG_1); return;
+    case 3:
+      PUSHMARK(MARK); SWIG_CALLXS(_wrap_new_Credential__SWIG_2); return;
+    }
+  }
+  
+  croak("No matching function for overloaded 'new_Credential'");
+  XSRETURN(0);
+}
+
+
+XS(_wrap_delete_Credential) {
+  {
+    ABAC::Credential *arg1 = (ABAC::Credential *) 0 ;
+    void *argp1 = 0 ;
+    int res1 = 0 ;
+    int argvi = 0;
+    dXSARGS;
+    
+    if ((items < 1) || (items > 1)) {
+      SWIG_croak("Usage: delete_Credential(self);");
+    }
+    res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_ABAC__Credential, SWIG_POINTER_DISOWN |  0 );
+    if (!SWIG_IsOK(res1)) {
+      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Credential" "', argument " "1"" of type '" "ABAC::Credential *""'"); 
+    }
+    arg1 = reinterpret_cast< ABAC::Credential * >(argp1);
+    {
+      try {
+        delete arg1;
+      }
+      catch (std::invalid_argument) {
+        croak("std::invalid_argument");
+      }
+      catch (std::logic_error) {
+        croak("std::logic_error");
+      }
+    }
+    ST(argvi) = sv_newmortal();
+    
+    XSRETURN(argvi);
+  fail:
+    
+    SWIG_croak_null();
+  }
+}
+
+
+XS(_wrap_Credential_head) {
+  {
+    ABAC::Credential *arg1 = (ABAC::Credential *) 0 ;
+    void *argp1 = 0 ;
+    int res1 = 0 ;
+    int argvi = 0;
+    ABAC::Role *result = 0 ;
+    dXSARGS;
+    
+    if ((items < 1) || (items > 1)) {
+      SWIG_croak("Usage: Credential_head(self);");
+    }
+    res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_ABAC__Credential, 0 |  0 );
+    if (!SWIG_IsOK(res1)) {
+      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Credential_head" "', argument " "1"" of type '" "ABAC::Credential *""'"); 
+    }
+    arg1 = reinterpret_cast< ABAC::Credential * >(argp1);
+    {
+      try {
+        result = (ABAC::Role *) &(arg1)->head();
+      }
+      catch (std::invalid_argument) {
+        croak("std::invalid_argument");
+      }
+      catch (std::logic_error) {
+        croak("std::logic_error");
+      }
+    }
+    ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ABAC__Role, 0 | SWIG_SHADOW); argvi++ ;
+    
+    XSRETURN(argvi);
+  fail:
+    
+    SWIG_croak_null();
+  }
+}
+
+
+XS(_wrap_Credential_tail) {
+  {
+    ABAC::Credential *arg1 = (ABAC::Credential *) 0 ;
+    void *argp1 = 0 ;
+    int res1 = 0 ;
+    int argvi = 0;
+    ABAC::Role *result = 0 ;
+    dXSARGS;
+    
+    if ((items < 1) || (items > 1)) {
+      SWIG_croak("Usage: Credential_tail(self);");
+    }
+    res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_ABAC__Credential, 0 |  0 );
+    if (!SWIG_IsOK(res1)) {
+      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Credential_tail" "', argument " "1"" of type '" "ABAC::Credential *""'"); 
+    }
+    arg1 = reinterpret_cast< ABAC::Credential * >(argp1);
+    {
+      try {
+        result = (ABAC::Role *) &(arg1)->tail();
+      }
+      catch (std::invalid_argument) {
+        croak("std::invalid_argument");
+      }
+      catch (std::logic_error) {
+        croak("std::logic_error");
+      }
+    }
+    ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ABAC__Role, 0 | SWIG_SHADOW); argvi++ ;
+    
+    XSRETURN(argvi);
+  fail:
+    
+    SWIG_croak_null();
+  }
+}
+
+
+XS(_wrap_Credential_attribute_cert) {
+  {
+    ABAC::Credential *arg1 = (ABAC::Credential *) 0 ;
+    void *argp1 = 0 ;
+    int res1 = 0 ;
+    int argvi = 0;
+    abac_chunk_t result;
+    dXSARGS;
+    
+    if ((items < 1) || (items > 1)) {
+      SWIG_croak("Usage: Credential_attribute_cert(self);");
+    }
+    res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_ABAC__Credential, 0 |  0 );
+    if (!SWIG_IsOK(res1)) {
+      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Credential_attribute_cert" "', argument " "1"" of type '" "ABAC::Credential *""'"); 
+    }
+    arg1 = reinterpret_cast< ABAC::Credential * >(argp1);
+    {
+      try {
+        result = (arg1)->attribute_cert();
+      }
+      catch (std::invalid_argument) {
+        croak("std::invalid_argument");
+      }
+      catch (std::logic_error) {
+        croak("std::logic_error");
+      }
+    }
+    {
+      ST(argvi) = newSVpvn(
+        (const char *)(&result)->ptr,
+        (&result)->len
+        );
+      ++argvi;
+    }
+    
+    XSRETURN(argvi);
+  fail:
+    
+    SWIG_croak_null();
+  }
+}
+
+
+XS(_wrap_Credential_issuer_cert) {
+  {
+    ABAC::Credential *arg1 = (ABAC::Credential *) 0 ;
+    void *argp1 = 0 ;
+    int res1 = 0 ;
+    int argvi = 0;
+    abac_chunk_t result;
+    dXSARGS;
+    
+    if ((items < 1) || (items > 1)) {
+      SWIG_croak("Usage: Credential_issuer_cert(self);");
+    }
+    res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_ABAC__Credential, 0 |  0 );
+    if (!SWIG_IsOK(res1)) {
+      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Credential_issuer_cert" "', argument " "1"" of type '" "ABAC::Credential *""'"); 
+    }
+    arg1 = reinterpret_cast< ABAC::Credential * >(argp1);
+    {
+      try {
+        result = (arg1)->issuer_cert();
+      }
+      catch (std::invalid_argument) {
+        croak("std::invalid_argument");
+      }
+      catch (std::logic_error) {
+        croak("std::logic_error");
+      }
+    }
+    {
+      ST(argvi) = newSVpvn(
+        (const char *)(&result)->ptr,
+        (&result)->len
+        );
+      ++argvi;
+    }
+    
+    XSRETURN(argvi);
+  fail:
+    
+    SWIG_croak_null();
+  }
+}
+
+
+XS(_wrap_new_ID__SWIG_0) {
+  {
+    int argvi = 0;
+    ABAC::ID *result = 0 ;
+    dXSARGS;
+    
+    if ((items < 0) || (items > 0)) {
+      SWIG_croak("Usage: new_ID();");
+    }
+    {
+      try {
+        result = (ABAC::ID *)new ABAC::ID();
+      }
+      catch (std::invalid_argument) {
+        croak("std::invalid_argument");
+      }
+      catch (std::logic_error) {
+        croak("std::logic_error");
+      }
+    }
+    ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ABAC__ID, SWIG_OWNER | SWIG_SHADOW); argvi++ ;
+    XSRETURN(argvi);
+  fail:
+    SWIG_croak_null();
+  }
+}
+
+
+XS(_wrap_new_ID__SWIG_1) {
+  {
+    ABAC::ID *arg1 = 0 ;
+    void *argp1 ;
+    int res1 = 0 ;
+    int argvi = 0;
+    ABAC::ID *result = 0 ;
+    dXSARGS;
+    
+    if ((items < 1) || (items > 1)) {
+      SWIG_croak("Usage: new_ID(id);");
+    }
+    res1 = SWIG_ConvertPtr(ST(0), &argp1, SWIGTYPE_p_ABAC__ID,  0 );
+    if (!SWIG_IsOK(res1)) {
+      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ID" "', argument " "1"" of type '" "ABAC::ID const &""'"); 
+    }
+    if (!argp1) {
+      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ID" "', argument " "1"" of type '" "ABAC::ID const &""'"); 
+    }
+    arg1 = reinterpret_cast< ABAC::ID * >(argp1);
+    {
+      try {
+        result = (ABAC::ID *)new ABAC::ID((ABAC::ID const &)*arg1);
+      }
+      catch (std::invalid_argument) {
+        croak("std::invalid_argument");
+      }
+      catch (std::logic_error) {
+        croak("std::logic_error");
+      }
+    }
+    ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ABAC__ID, SWIG_OWNER | SWIG_SHADOW); argvi++ ;
+    
+    XSRETURN(argvi);
+  fail:
+    
+    SWIG_croak_null();
+  }
+}
+
+
+XS(_wrap_delete_ID) {
+  {
+    ABAC::ID *arg1 = (ABAC::ID *) 0 ;
+    void *argp1 = 0 ;
+    int res1 = 0 ;
+    int argvi = 0;
+    dXSARGS;
+    
+    if ((items < 1) || (items > 1)) {
+      SWIG_croak("Usage: delete_ID(self);");
+    }
+    res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_ABAC__ID, SWIG_POINTER_DISOWN |  0 );
+    if (!SWIG_IsOK(res1)) {
+      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ID" "', argument " "1"" of type '" "ABAC::ID *""'"); 
+    }
+    arg1 = reinterpret_cast< ABAC::ID * >(argp1);
+    {
+      try {
+        delete arg1;
+      }
+      catch (std::invalid_argument) {
+        croak("std::invalid_argument");
+      }
+      catch (std::logic_error) {
+        croak("std::logic_error");
+      }
+    }
+    ST(argvi) = sv_newmortal();
+    
+    XSRETURN(argvi);
+  fail:
+    
+    SWIG_croak_null();
+  }
+}
+
+
+XS(_wrap_new_ID__SWIG_2) {
+  {
+    char *arg1 = (char *) 0 ;
+    int res1 ;
+    char *buf1 = 0 ;
+    int alloc1 = 0 ;
+    int argvi = 0;
+    ABAC::ID *result = 0 ;
+    dXSARGS;
+    
+    if ((items < 1) || (items > 1)) {
+      SWIG_croak("Usage: new_ID(filename);");
+    }
+    res1 = SWIG_AsCharPtrAndSize(ST(0), &buf1, NULL, &alloc1);
+    if (!SWIG_IsOK(res1)) {
+      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ID" "', argument " "1"" of type '" "char *""'");
+    }
+    arg1 = reinterpret_cast< char * >(buf1);
+    {
+      try {
+        result = (ABAC::ID *)new ABAC::ID(arg1);
+      }
+      catch (std::invalid_argument) {
+        croak("std::invalid_argument");
+      }
+      catch (std::logic_error) {
+        croak("std::logic_error");
+      }
+    }
+    ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ABAC__ID, SWIG_OWNER | SWIG_SHADOW); argvi++ ;
+    if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
+    XSRETURN(argvi);
+  fail:
+    if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
+    SWIG_croak_null();
+  }
+}
+
+
+XS(_wrap_new_ID_chunk) {
+  {
+    abac_chunk_t arg1 ;
+    int argvi = 0;
+    ABAC::ID *result = 0 ;
+    dXSARGS;
+    
+    if ((items < 1) || (items > 1)) {
+      SWIG_croak("Usage: new_ID_chunk(chunk);");
+    }
+    {
+      STRLEN len;
+      (&arg1)->ptr = (unsigned char *)SvPV(ST(0), len);
+      (&arg1)->len = len;
+    }
+    {
+      try {
+        result = (ABAC::ID *)new ABAC::ID(arg1);
+      }
+      catch (std::invalid_argument) {
+        croak("std::invalid_argument");
+      }
+      catch (std::logic_error) {
+        croak("std::logic_error");
+      }
+    }
+    ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ABAC__ID, SWIG_OWNER | SWIG_SHADOW); argvi++ ;
+    XSRETURN(argvi);
+  fail:
+    SWIG_croak_null();
+  }
+}
+
+
+XS(_wrap_new_ID__SWIG_3) {
+  {
+    char *arg1 = (char *) 0 ;
+    int arg2 ;
+    int res1 ;
+    char *buf1 = 0 ;
+    int alloc1 = 0 ;
+    int val2 ;
+    int ecode2 = 0 ;
+    int argvi = 0;
+    ABAC::ID *result = 0 ;
+    dXSARGS;
+    
+    if ((items < 2) || (items > 2)) {
+      SWIG_croak("Usage: new_ID(cn,validity);");
+    }
+    res1 = SWIG_AsCharPtrAndSize(ST(0), &buf1, NULL, &alloc1);
+    if (!SWIG_IsOK(res1)) {
+      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ID" "', argument " "1"" of type '" "char *""'");
+    }
+    arg1 = reinterpret_cast< char * >(buf1);
+    ecode2 = SWIG_AsVal_int SWIG_PERL_CALL_ARGS_2(ST(1), &val2);
+    if (!SWIG_IsOK(ecode2)) {
+      SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ID" "', argument " "2"" of type '" "int""'");
+    } 
+    arg2 = static_cast< int >(val2);
+    {
+      try {
+        result = (ABAC::ID *)new ABAC::ID(arg1,arg2);
+      }
+      catch (std::invalid_argument) {
+        croak("std::invalid_argument");
+      }
+      catch (std::logic_error) {
+        croak("std::logic_error");
+      }
+    }
+    ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ABAC__ID, SWIG_OWNER | SWIG_SHADOW); argvi++ ;
+    if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
+    
+    XSRETURN(argvi);
+  fail:
+    if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
+    
+    SWIG_croak_null();
+  }
+}
+
+
+XS(_wrap_new_ID) {
+  dXSARGS;
+  
+  {
+    unsigned long _index = 0;
+    SWIG_TypeRank _rank = 0; 
+    if (items == 0) {
+      SWIG_TypeRank _ranki = 0;
+      SWIG_TypeRank _rankm = 0;
+      if (!_index || (_ranki < _rank)) {
+        _rank = _ranki; _index = 1;
+        if (_rank == _rankm) goto dispatch;
+      }
+    }
+    if (items == 1) {
+      SWIG_TypeRank _ranki = 0;
+      SWIG_TypeRank _rankm = 0;
+      SWIG_TypeRank _pi = 1;
+      int _v = 0;
+      {
+        void *vptr = 0;
+        int res = SWIG_ConvertPtr(ST(0), &vptr, SWIGTYPE_p_ABAC__ID, 0);
+        _v = SWIG_CheckState(res);
+      }
+      if (!_v) goto check_2;
+      _ranki += _v*_pi;
+      _rankm += _pi;
+      _pi *= SWIG_MAXCASTRANK;
+      if (!_index || (_ranki < _rank)) {
+        _rank = _ranki; _index = 2;
+        if (_rank == _rankm) goto dispatch;
+      }
+    }
+  check_2:
+    
+    if (items == 1) {
+      SWIG_TypeRank _ranki = 0;
+      SWIG_TypeRank _rankm = 0;
+      SWIG_TypeRank _pi = 1;
+      int _v = 0;
+      {
+        int res = SWIG_AsCharPtrAndSize(ST(0), 0, NULL, 0);
+        _v = SWIG_CheckState(res);
+      }
+      if (!_v) goto check_3;
+      _ranki += _v*_pi;
+      _rankm += _pi;
+      _pi *= SWIG_MAXCASTRANK;
+      if (!_index || (_ranki < _rank)) {
+        _rank = _ranki; _index = 3;
+        if (_rank == _rankm) goto dispatch;
+      }
+    }
+  check_3:
+    
+    if (items == 2) {
+      SWIG_TypeRank _ranki = 0;
+      SWIG_TypeRank _rankm = 0;
+      SWIG_TypeRank _pi = 1;
+      int _v = 0;
+      {
+        int res = SWIG_AsCharPtrAndSize(ST(0), 0, NULL, 0);
+        _v = SWIG_CheckState(res);
+      }
+      if (!_v) goto check_4;
+      _ranki += _v*_pi;
+      _rankm += _pi;
+      _pi *= SWIG_MAXCASTRANK;
+      {
+        {
+          int res = SWIG_AsVal_int SWIG_PERL_CALL_ARGS_2(ST(1), NULL);
+          _v = SWIG_CheckState(res);
+        }
+      }
+      if (!_v) goto check_4;
+      _ranki += _v*_pi;
+      _rankm += _pi;
+      _pi *= SWIG_MAXCASTRANK;
+      if (!_index || (_ranki < _rank)) {
+        _rank = _ranki; _index = 4;
+        if (_rank == _rankm) goto dispatch;
+      }
+    }
+  check_4:
+    
+  dispatch:
+    switch(_index) {
+    case 1:
+      PUSHMARK(MARK); SWIG_CALLXS(_wrap_new_ID__SWIG_0); return;
+    case 2:
+      PUSHMARK(MARK); SWIG_CALLXS(_wrap_new_ID__SWIG_1); return;
+    case 3:
+      PUSHMARK(MARK); SWIG_CALLXS(_wrap_new_ID__SWIG_2); return;
+    case 4:
+      PUSHMARK(MARK); SWIG_CALLXS(_wrap_new_ID__SWIG_3); return;
+    }
+  }
+  
+  croak("No matching function for overloaded 'new_ID'");
+  XSRETURN(0);
+}
+
+
+XS(_wrap_ID_load_privkey) {
+  {
+    ABAC::ID *arg1 = (ABAC::ID *) 0 ;
+    char *arg2 = (char *) 0 ;
+    void *argp1 = 0 ;
+    int res1 = 0 ;
+    int res2 ;
+    char *buf2 = 0 ;
+    int alloc2 = 0 ;
+    int argvi = 0;
+    dXSARGS;
+    
+    if ((items < 2) || (items > 2)) {
+      SWIG_croak("Usage: ID_load_privkey(self,filename);");
+    }
+    res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_ABAC__ID, 0 |  0 );
+    if (!SWIG_IsOK(res1)) {
+      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ID_load_privkey" "', argument " "1"" of type '" "ABAC::ID *""'"); 
+    }
+    arg1 = reinterpret_cast< ABAC::ID * >(argp1);
+    res2 = SWIG_AsCharPtrAndSize(ST(1), &buf2, NULL, &alloc2);
+    if (!SWIG_IsOK(res2)) {
+      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ID_load_privkey" "', argument " "2"" of type '" "char *""'");
+    }
+    arg2 = reinterpret_cast< char * >(buf2);
+    {
+      try {
+        (arg1)->load_privkey(arg2);
+      }
+      catch (std::invalid_argument) {
+        croak("std::invalid_argument");
+      }
+      catch (std::logic_error) {
+        croak("std::logic_error");
+      }
+    }
+    ST(argvi) = sv_newmortal();
+    
+    if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
+    XSRETURN(argvi);
+  fail:
+    
+    if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
+    SWIG_croak_null();
+  }
+}
+
+
+XS(_wrap_ID_load_privkey_chunk) {
+  {
+    ABAC::ID *arg1 = (ABAC::ID *) 0 ;
+    abac_chunk_t arg2 ;
+    void *argp1 = 0 ;
+    int res1 = 0 ;
+    int argvi = 0;
+    dXSARGS;
+    
+    if ((items < 2) || (items > 2)) {
+      SWIG_croak("Usage: ID_load_privkey_chunk(self,chunk);");
+    }
+    res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_ABAC__ID, 0 |  0 );
+    if (!SWIG_IsOK(res1)) {
+      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ID_load_privkey_chunk" "', argument " "1"" of type '" "ABAC::ID *""'"); 
+    }
+    arg1 = reinterpret_cast< ABAC::ID * >(argp1);
+    {
+      STRLEN len;
+      (&arg2)->ptr = (unsigned char *)SvPV(ST(1), len);
+      (&arg2)->len = len;
+    }
+    {
+      try {
+        (arg1)->load_privkey_chunk(arg2);
+      }
+      catch (std::invalid_argument) {
+        croak("std::invalid_argument");
+      }
+      catch (std::logic_error) {
+        croak("std::logic_error");
+      }
+    }
+    ST(argvi) = sv_newmortal();
+    
+    XSRETURN(argvi);
+  fail:
+    
+    SWIG_croak_null();
+  }
+}
+
+
+XS(_wrap_ID_has_privkey) {
+  {
+    ABAC::ID *arg1 = (ABAC::ID *) 0 ;
+    void *argp1 = 0 ;
+    int res1 = 0 ;
+    int argvi = 0;
+    int result;
+    dXSARGS;
+    
+    if ((items < 1) || (items > 1)) {
+      SWIG_croak("Usage: ID_has_privkey(self);");
+    }
+    res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_ABAC__ID, 0 |  0 );
+    if (!SWIG_IsOK(res1)) {
+      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ID_has_privkey" "', argument " "1"" of type '" "ABAC::ID *""'"); 
+    }
+    arg1 = reinterpret_cast< ABAC::ID * >(argp1);
+    {
+      try {
+        result = (int)(arg1)->has_privkey();
+      }
+      catch (std::invalid_argument) {
+        croak("std::invalid_argument");
+      }
+      catch (std::logic_error) {
+        croak("std::logic_error");
+      }
+    }
+    ST(argvi) = SWIG_From_int  SWIG_PERL_CALL_ARGS_1(static_cast< int >(result)); argvi++ ;
+    
+    XSRETURN(argvi);
+  fail:
+    
+    SWIG_croak_null();
+  }
+}
+
+
+XS(_wrap_ID_keyid) {
+  {
+    ABAC::ID *arg1 = (ABAC::ID *) 0 ;
+    void *argp1 = 0 ;
+    int res1 = 0 ;
+    int argvi = 0;
+    char *result = 0 ;
+    dXSARGS;
+    
+    if ((items < 1) || (items > 1)) {
+      SWIG_croak("Usage: ID_keyid(self);");
+    }
+    res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_ABAC__ID, 0 |  0 );
+    if (!SWIG_IsOK(res1)) {
+      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ID_keyid" "', argument " "1"" of type '" "ABAC::ID *""'"); 
+    }
+    arg1 = reinterpret_cast< ABAC::ID * >(argp1);
+    {
+      try {
+        result = (char *)(arg1)->keyid();
+      }
+      catch (std::invalid_argument) {
+        croak("std::invalid_argument");
+      }
+      catch (std::logic_error) {
+        croak("std::logic_error");
+      }
+    }
+    ST(argvi) = SWIG_FromCharPtr((const char *)result); argvi++ ;
+    
+    XSRETURN(argvi);
+  fail:
+    
+    SWIG_croak_null();
+  }
+}
+
+
+XS(_wrap_ID_cn) {
+  {
+    ABAC::ID *arg1 = (ABAC::ID *) 0 ;
+    void *argp1 = 0 ;
+    int res1 = 0 ;
+    int argvi = 0;
+    char *result = 0 ;
+    dXSARGS;
+    
+    if ((items < 1) || (items > 1)) {
+      SWIG_croak("Usage: ID_cn(self);");
+    }
+    res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_ABAC__ID, 0 |  0 );
+    if (!SWIG_IsOK(res1)) {
+      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ID_cn" "', argument " "1"" of type '" "ABAC::ID *""'"); 
+    }
+    arg1 = reinterpret_cast< ABAC::ID * >(argp1);
+    {
+      try {
+        result = (char *)(arg1)->cn();
+      }
+      catch (std::invalid_argument) {
+        croak("std::invalid_argument");
+      }
+      catch (std::logic_error) {
+        croak("std::logic_error");
+      }
+    }
+    ST(argvi) = SWIG_FromCharPtr((const char *)result); argvi++ ;
+    
+    XSRETURN(argvi);
+  fail:
+    
+    SWIG_croak_null();
+  }
+}
+
+
+XS(_wrap_ID_cert_filename) {
+  {
+    ABAC::ID *arg1 = (ABAC::ID *) 0 ;
+    void *argp1 = 0 ;
+    int res1 = 0 ;
+    int argvi = 0;
+    char *result = 0 ;
+    dXSARGS;
+    
+    if ((items < 1) || (items > 1)) {
+      SWIG_croak("Usage: ID_cert_filename(self);");
+    }
+    res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_ABAC__ID, 0 |  0 );
+    if (!SWIG_IsOK(res1)) {
+      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ID_cert_filename" "', argument " "1"" of type '" "ABAC::ID *""'"); 
+    }
+    arg1 = reinterpret_cast< ABAC::ID * >(argp1);
+    {
+      try {
+        result = (char *)(arg1)->cert_filename();
+      }
+      catch (std::invalid_argument) {
+        croak("std::invalid_argument");
+      }
+      catch (std::logic_error) {
+        croak("std::logic_error");
+      }
+    }
+    ST(argvi) = SWIG_FromCharPtr((const char *)result); argvi++ ;
+    
+    XSRETURN(argvi);
+  fail:
+    
+    SWIG_croak_null();
+  }
+}
+
+
+XS(_wrap_ID_write_cert) {
+  {
+    ABAC::ID *arg1 = (ABAC::ID *) 0 ;
+    FILE *arg2 = (FILE *) 0 ;
+    void *argp1 = 0 ;
+    int res1 = 0 ;
+    void *argp2 = 0 ;
+    int res2 = 0 ;
+    int argvi = 0;
+    dXSARGS;
+    
+    if ((items < 2) || (items > 2)) {
+      SWIG_croak("Usage: ID_write_cert(self,out);");
+    }
+    res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_ABAC__ID, 0 |  0 );
+    if (!SWIG_IsOK(res1)) {
+      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ID_write_cert" "', argument " "1"" of type '" "ABAC::ID *""'"); 
+    }
+    arg1 = reinterpret_cast< ABAC::ID * >(argp1);
+    res2 = SWIG_ConvertPtr(ST(1), &argp2,SWIGTYPE_p_FILE, 0 |  0 );
+    if (!SWIG_IsOK(res2)) {
+      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ID_write_cert" "', argument " "2"" of type '" "FILE *""'"); 
+    }
+    arg2 = reinterpret_cast< FILE * >(argp2);
+    {
+      try {
+        (arg1)->write_cert(arg2);
+      }
+      catch (std::invalid_argument) {
+        croak("std::invalid_argument");
+      }
+      catch (std::logic_error) {
+        croak("std::logic_error");
+      }
+    }
+    ST(argvi) = sv_newmortal();
+    
+    
+    XSRETURN(argvi);
+  fail:
+    
+    
+    SWIG_croak_null();
+  }
+}
+
+
+XS(_wrap_ID_write_cert_file) {
+  {
+    ABAC::ID *arg1 = (ABAC::ID *) 0 ;
+    char *arg2 = (char *) 0 ;
+    void *argp1 = 0 ;
+    int res1 = 0 ;
+    int res2 ;
+    char *buf2 = 0 ;
+    int alloc2 = 0 ;
+    int argvi = 0;
+    dXSARGS;
+    
+    if ((items < 2) || (items > 2)) {
+      SWIG_croak("Usage: ID_write_cert_file(self,n);");
+    }
+    res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_ABAC__ID, 0 |  0 );
+    if (!SWIG_IsOK(res1)) {
+      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ID_write_cert_file" "', argument " "1"" of type '" "ABAC::ID *""'"); 
+    }
+    arg1 = reinterpret_cast< ABAC::ID * >(argp1);
+    res2 = SWIG_AsCharPtrAndSize(ST(1), &buf2, NULL, &alloc2);
+    if (!SWIG_IsOK(res2)) {
+      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ID_write_cert_file" "', argument " "2"" of type '" "char const *""'");
+    }
+    arg2 = reinterpret_cast< char * >(buf2);
+    {
+      try {
+        (arg1)->write_cert_file((char const *)arg2);
+      }
+      catch (std::invalid_argument) {
+        croak("std::invalid_argument");
+      }
+      catch (std::logic_error) {
+        croak("std::logic_error");
+      }
+    }
+    ST(argvi) = sv_newmortal();
+    
+    if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
+    XSRETURN(argvi);
+  fail:
+    
+    if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
+    SWIG_croak_null();
+  }
+}
+
+
+XS(_wrap_ID_write_cert_name) {
+  {
+    ABAC::ID *arg1 = (ABAC::ID *) 0 ;
+    char *arg2 = (char *) 0 ;
+    void *argp1 = 0 ;
+    int res1 = 0 ;
+    int res2 ;
+    char *buf2 = 0 ;
+    int alloc2 = 0 ;
+    int argvi = 0;
+    dXSARGS;
+    
+    if ((items < 2) || (items > 2)) {
+      SWIG_croak("Usage: ID_write_cert_name(self,n);");
+    }
+    res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_ABAC__ID, 0 |  0 );
+    if (!SWIG_IsOK(res1)) {
+      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ID_write_cert_name" "', argument " "1"" of type '" "ABAC::ID *""'"); 
+    }
+    arg1 = reinterpret_cast< ABAC::ID * >(argp1);
+    res2 = SWIG_AsCharPtrAndSize(ST(1), &buf2, NULL, &alloc2);
+    if (!SWIG_IsOK(res2)) {
+      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ID_write_cert_name" "', argument " "2"" of type '" "char const *""'");
+    }
+    arg2 = reinterpret_cast< char * >(buf2);
+    {
+      try {
+        (arg1)->write_cert_name((char const *)arg2);
+      }
+      catch (std::invalid_argument) {
+        croak("std::invalid_argument");
+      }
+      catch (std::logic_error) {
+        croak("std::logic_error");
+      }
+    }
+    ST(argvi) = sv_newmortal();
+    
+    if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
+    XSRETURN(argvi);
+  fail:
+    
+    if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
+    SWIG_croak_null();
+  }
+}
+
+
+XS(_wrap_ID_privkey_filename) {
+  {
+    ABAC::ID *arg1 = (ABAC::ID *) 0 ;
+    void *argp1 = 0 ;
+    int res1 = 0 ;
+    int argvi = 0;
+    char *result = 0 ;
+    dXSARGS;
+    
+    if ((items < 1) || (items > 1)) {
+      SWIG_croak("Usage: ID_privkey_filename(self);");
+    }
+    res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_ABAC__ID, 0 |  0 );
+    if (!SWIG_IsOK(res1)) {
+      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ID_privkey_filename" "', argument " "1"" of type '" "ABAC::ID *""'"); 
+    }
+    arg1 = reinterpret_cast< ABAC::ID * >(argp1);
+    {
+      try {
+        result = (char *)(arg1)->privkey_filename();
+      }
+      catch (std::invalid_argument) {
+        croak("std::invalid_argument");
+      }
+      catch (std::logic_error) {
+        croak("std::logic_error");
+      }
+    }
+    ST(argvi) = SWIG_FromCharPtr((const char *)result); argvi++ ;
+    
+    XSRETURN(argvi);
+  fail:
+    
+    SWIG_croak_null();
+  }
+}
+
+
+XS(_wrap_ID_write_privkey) {
+  {
+    ABAC::ID *arg1 = (ABAC::ID *) 0 ;
+    FILE *arg2 = (FILE *) 0 ;
+    void *argp1 = 0 ;
+    int res1 = 0 ;
+    void *argp2 = 0 ;
+    int res2 = 0 ;
+    int argvi = 0;
+    dXSARGS;
+    
+    if ((items < 2) || (items > 2)) {
+      SWIG_croak("Usage: ID_write_privkey(self,out);");
+    }
+    res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_ABAC__ID, 0 |  0 );
+    if (!SWIG_IsOK(res1)) {
+      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ID_write_privkey" "', argument " "1"" of type '" "ABAC::ID *""'"); 
+    }
+    arg1 = reinterpret_cast< ABAC::ID * >(argp1);
+    res2 = SWIG_ConvertPtr(ST(1), &argp2,SWIGTYPE_p_FILE, 0 |  0 );
+    if (!SWIG_IsOK(res2)) {
+      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ID_write_privkey" "', argument " "2"" of type '" "FILE *""'"); 
+    }
+    arg2 = reinterpret_cast< FILE * >(argp2);
+    {
+      try {
+        (arg1)->write_privkey(arg2);
+      }
+      catch (std::invalid_argument) {
+        croak("std::invalid_argument");
+      }
+      catch (std::logic_error) {
+        croak("std::logic_error");
+      }
+    }
+    ST(argvi) = sv_newmortal();
+    
+    
+    XSRETURN(argvi);
+  fail:
+    
+    
+    SWIG_croak_null();
+  }
+}
+
+
+XS(_wrap_ID_write_privkey_file) {
+  {
+    ABAC::ID *arg1 = (ABAC::ID *) 0 ;
+    char *arg2 = (char *) 0 ;
+    void *argp1 = 0 ;
+    int res1 = 0 ;
+    int res2 ;
+    char *buf2 = 0 ;
+    int alloc2 = 0 ;
+    int argvi = 0;
+    dXSARGS;
+    
+    if ((items < 2) || (items > 2)) {
+      SWIG_croak("Usage: ID_write_privkey_file(self,name);");
+    }
+    res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_ABAC__ID, 0 |  0 );
+    if (!SWIG_IsOK(res1)) {
+      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ID_write_privkey_file" "', argument " "1"" of type '" "ABAC::ID *""'"); 
+    }
+    arg1 = reinterpret_cast< ABAC::ID * >(argp1);
+    res2 = SWIG_AsCharPtrAndSize(ST(1), &buf2, NULL, &alloc2);
+    if (!SWIG_IsOK(res2)) {
+      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ID_write_privkey_file" "', argument " "2"" of type '" "char const *""'");
+    }
+    arg2 = reinterpret_cast< char * >(buf2);
+    {
+      try {
+        (arg1)->write_privkey_file((char const *)arg2);
+      }
+      catch (std::invalid_argument) {
+        croak("std::invalid_argument");
+      }
+      catch (std::logic_error) {
+        croak("std::logic_error");
+      }
+    }
+    ST(argvi) = sv_newmortal();
+    
+    if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
+    XSRETURN(argvi);
+  fail:
+    
+    if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
+    SWIG_croak_null();
+  }
+}
+
+
+XS(_wrap_ID_write_privkey_name) {
+  {
+    ABAC::ID *arg1 = (ABAC::ID *) 0 ;
+    char *arg2 = (char *) 0 ;
+    void *argp1 = 0 ;
+    int res1 = 0 ;
+    int res2 ;
+    char *buf2 = 0 ;
+    int alloc2 = 0 ;
+    int argvi = 0;
+    dXSARGS;
+    
+    if ((items < 2) || (items > 2)) {
+      SWIG_croak("Usage: ID_write_privkey_name(self,name);");
+    }
+    res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_ABAC__ID, 0 |  0 );
+    if (!SWIG_IsOK(res1)) {
+      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ID_write_privkey_name" "', argument " "1"" of type '" "ABAC::ID *""'"); 
+    }
+    arg1 = reinterpret_cast< ABAC::ID * >(argp1);
+    res2 = SWIG_AsCharPtrAndSize(ST(1), &buf2, NULL, &alloc2);
+    if (!SWIG_IsOK(res2)) {
+      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ID_write_privkey_name" "', argument " "2"" of type '" "char const *""'");
+    }
+    arg2 = reinterpret_cast< char * >(buf2);
+    {
+      try {
+        (arg1)->write_privkey_name((char const *)arg2);
+      }
+      catch (std::invalid_argument) {
+        croak("std::invalid_argument");
+      }
+      catch (std::logic_error) {
+        croak("std::logic_error");
+      }
+    }
+    ST(argvi) = sv_newmortal();
+    
+    if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
+    XSRETURN(argvi);
+  fail:
+    
+    if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
+    SWIG_croak_null();
+  }
+}
+
+
+XS(_wrap_ID_cert_chunk) {
+  {
+    ABAC::ID *arg1 = (ABAC::ID *) 0 ;
+    void *argp1 = 0 ;
+    int res1 = 0 ;
+    int argvi = 0;
+    abac_chunk_t result;
+    dXSARGS;
+    
+    if ((items < 1) || (items > 1)) {
+      SWIG_croak("Usage: ID_cert_chunk(self);");
+    }
+    res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_ABAC__ID, 0 |  0 );
+    if (!SWIG_IsOK(res1)) {
+      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ID_cert_chunk" "', argument " "1"" of type '" "ABAC::ID *""'"); 
+    }
+    arg1 = reinterpret_cast< ABAC::ID * >(argp1);
+    {
+      try {
+        result = (arg1)->cert_chunk();
+      }
+      catch (std::invalid_argument) {
+        croak("std::invalid_argument");
+      }
+      catch (std::logic_error) {
+        croak("std::logic_error");
+      }
+    }
+    {
+      ST(argvi) = newSVpvn(
+        (const char *)(&result)->ptr,
+        (&result)->len
+        );
+      ++argvi;
+    }
+    
+    XSRETURN(argvi);
+  fail:
+    
+    SWIG_croak_null();
+  }
+}
+
+
+XS(_wrap_ID_privkey_chunk) {
+  {
+    ABAC::ID *arg1 = (ABAC::ID *) 0 ;
+    void *argp1 = 0 ;
+    int res1 = 0 ;
+    int argvi = 0;
+    abac_chunk_t result;
+    dXSARGS;
+    
+    if ((items < 1) || (items > 1)) {
+      SWIG_croak("Usage: ID_privkey_chunk(self);");
+    }
+    res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_ABAC__ID, 0 |  0 );
+    if (!SWIG_IsOK(res1)) {
+      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ID_privkey_chunk" "', argument " "1"" of type '" "ABAC::ID *""'"); 
+    }
+    arg1 = reinterpret_cast< ABAC::ID * >(argp1);
+    {
+      try {
+        result = (arg1)->privkey_chunk();
+      }
+      catch (std::invalid_argument) {
+        croak("std::invalid_argument");
+      }
+      catch (std::logic_error) {
+        croak("std::logic_error");
+      }
+    }
+    {
+      ST(argvi) = newSVpvn(
+        (const char *)(&result)->ptr,
+        (&result)->len
+        );
+      ++argvi;
+    }
+    
+    XSRETURN(argvi);
+  fail:
+    
+    SWIG_croak_null();
+  }
+}
+
+
+XS(_wrap_new_Attribute__SWIG_0) {
+  {
+    int argvi = 0;
+    ABAC::Attribute *result = 0 ;
+    dXSARGS;
+    
+    if ((items < 0) || (items > 0)) {
+      SWIG_croak("Usage: new_Attribute();");
+    }
+    {
+      try {
+        result = (ABAC::Attribute *)new ABAC::Attribute();
+      }
+      catch (std::invalid_argument) {
+        croak("std::invalid_argument");
+      }
+      catch (std::logic_error) {
+        croak("std::logic_error");
+      }
+    }
+    ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ABAC__Attribute, SWIG_OWNER | SWIG_SHADOW); argvi++ ;
+    XSRETURN(argvi);
+  fail:
+    SWIG_croak_null();
+  }
+}
+
+
+XS(_wrap_delete_Attribute) {
+  {
+    ABAC::Attribute *arg1 = (ABAC::Attribute *) 0 ;
+    void *argp1 = 0 ;
+    int res1 = 0 ;
+    int argvi = 0;
+    dXSARGS;
+    
+    if ((items < 1) || (items > 1)) {
+      SWIG_croak("Usage: delete_Attribute(self);");
+    }
+    res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_ABAC__Attribute, SWIG_POINTER_DISOWN |  0 );
+    if (!SWIG_IsOK(res1)) {
+      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Attribute" "', argument " "1"" of type '" "ABAC::Attribute *""'"); 
+    }
+    arg1 = reinterpret_cast< ABAC::Attribute * >(argp1);
+    {
+      try {
+        delete arg1;
+      }
+      catch (std::invalid_argument) {
+        croak("std::invalid_argument");
+      }
+      catch (std::logic_error) {
+        croak("std::logic_error");
+      }
+    }
+    ST(argvi) = sv_newmortal();
+    
+    XSRETURN(argvi);
+  fail:
+    
+    SWIG_croak_null();
+  }
+}
+
+
+XS(_wrap_new_Attribute__SWIG_1) {
+  {
+    ABAC::ID *arg1 = 0 ;
+    char *arg2 = (char *) 0 ;
+    int arg3 ;
+    void *argp1 = 0 ;
+    int res1 = 0 ;
+    int res2 ;
+    char *buf2 = 0 ;
+    int alloc2 = 0 ;
+    int val3 ;
+    int ecode3 = 0 ;
+    int argvi = 0;
+    ABAC::Attribute *result = 0 ;
+    dXSARGS;
+    
+    if ((items < 3) || (items > 3)) {
+      SWIG_croak("Usage: new_Attribute(issuer,role,validity);");
+    }
+    res1 = SWIG_ConvertPtr(ST(0), &argp1, SWIGTYPE_p_ABAC__ID,  0 );
+    if (!SWIG_IsOK(res1)) {
+      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Attribute" "', argument " "1"" of type '" "ABAC::ID &""'"); 
+    }
+    if (!argp1) {
+      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Attribute" "', argument " "1"" of type '" "ABAC::ID &""'"); 
+    }
+    arg1 = reinterpret_cast< ABAC::ID * >(argp1);
+    res2 = SWIG_AsCharPtrAndSize(ST(1), &buf2, NULL, &alloc2);
+    if (!SWIG_IsOK(res2)) {
+      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_Attribute" "', argument " "2"" of type '" "char *""'");
+    }
+    arg2 = reinterpret_cast< char * >(buf2);
+    ecode3 = SWIG_AsVal_int SWIG_PERL_CALL_ARGS_2(ST(2), &val3);
+    if (!SWIG_IsOK(ecode3)) {
+      SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Attribute" "', argument " "3"" of type '" "int""'");
+    } 
+    arg3 = static_cast< int >(val3);
+    {
+      try {
+        result = (ABAC::Attribute *)new ABAC::Attribute(*arg1,arg2,arg3);
+      }
+      catch (std::invalid_argument) {
+        croak("std::invalid_argument");
+      }
+      catch (std::logic_error) {
+        croak("std::logic_error");
+      }
+    }
+    ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ABAC__Attribute, SWIG_OWNER | SWIG_SHADOW); argvi++ ;
+    
+    if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
+    
+    XSRETURN(argvi);
+  fail:
+    
+    if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
+    
+    SWIG_croak_null();
+  }
+}
+
+
+XS(_wrap_new_Attribute) {
+  dXSARGS;
+  
+  {
+    unsigned long _index = 0;
+    SWIG_TypeRank _rank = 0; 
+    if (items == 0) {
+      SWIG_TypeRank _ranki = 0;
+      SWIG_TypeRank _rankm = 0;
+      if (!_index || (_ranki < _rank)) {
+        _rank = _ranki; _index = 1;
+        if (_rank == _rankm) goto dispatch;
+      }
+    }
+    if (items == 3) {
+      SWIG_TypeRank _ranki = 0;
+      SWIG_TypeRank _rankm = 0;
+      SWIG_TypeRank _pi = 1;
+      int _v = 0;
+      {
+        void *vptr = 0;
+        int res = SWIG_ConvertPtr(ST(0), &vptr, SWIGTYPE_p_ABAC__ID, 0);
+        _v = SWIG_CheckState(res);
+      }
+      if (!_v) goto check_2;
+      _ranki += _v*_pi;
+      _rankm += _pi;
+      _pi *= SWIG_MAXCASTRANK;
+      {
+        int res = SWIG_AsCharPtrAndSize(ST(1), 0, NULL, 0);
+        _v = SWIG_CheckState(res);
+      }
+      if (!_v) goto check_2;
+      _ranki += _v*_pi;
+      _rankm += _pi;
+      _pi *= SWIG_MAXCASTRANK;
+      {
+        {
+          int res = SWIG_AsVal_int SWIG_PERL_CALL_ARGS_2(ST(2), NULL);
+          _v = SWIG_CheckState(res);
+        }
+      }
+      if (!_v) goto check_2;
+      _ranki += _v*_pi;
+      _rankm += _pi;
+      _pi *= SWIG_MAXCASTRANK;
+      if (!_index || (_ranki < _rank)) {
+        _rank = _ranki; _index = 2;
+        if (_rank == _rankm) goto dispatch;
+      }
+    }
+  check_2:
+    
+  dispatch:
+    switch(_index) {
+    case 1:
+      PUSHMARK(MARK); SWIG_CALLXS(_wrap_new_Attribute__SWIG_0); return;
+    case 2:
+      PUSHMARK(MARK); SWIG_CALLXS(_wrap_new_Attribute__SWIG_1); return;
+    }
+  }
+  
+  croak("No matching function for overloaded 'new_Attribute'");
+  XSRETURN(0);
+}
+
+
+XS(_wrap_Attribute_principal) {
+  {
+    ABAC::Attribute *arg1 = (ABAC::Attribute *) 0 ;
+    char *arg2 = (char *) 0 ;
+    void *argp1 = 0 ;
+    int res1 = 0 ;
+    int res2 ;
+    char *buf2 = 0 ;
+    int alloc2 = 0 ;
+    int argvi = 0;
+    bool result;
+    dXSARGS;
+    
+    if ((items < 2) || (items > 2)) {
+      SWIG_croak("Usage: Attribute_principal(self,keyid);");
+    }
+    res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_ABAC__Attribute, 0 |  0 );
+    if (!SWIG_IsOK(res1)) {
+      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Attribute_principal" "', argument " "1"" of type '" "ABAC::Attribute *""'"); 
+    }
+    arg1 = reinterpret_cast< ABAC::Attribute * >(argp1);
+    res2 = SWIG_AsCharPtrAndSize(ST(1), &buf2, NULL, &alloc2);
+    if (!SWIG_IsOK(res2)) {
+      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Attribute_principal" "', argument " "2"" of type '" "char *""'");
+    }
+    arg2 = reinterpret_cast< char * >(buf2);
+    {
+      try {
+        result = (bool)(arg1)->principal(arg2);
+      }
+      catch (std::invalid_argument) {
+        croak("std::invalid_argument");
+      }
+      catch (std::logic_error) {
+        croak("std::logic_error");
+      }
+    }
+    ST(argvi) = SWIG_From_bool  SWIG_PERL_CALL_ARGS_1(static_cast< bool >(result)); argvi++ ;
+    
+    if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
+    XSRETURN(argvi);
+  fail:
+    
+    if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
+    SWIG_croak_null();
+  }
+}
+
+
+XS(_wrap_Attribute_role) {
+  {
+    ABAC::Attribute *arg1 = (ABAC::Attribute *) 0 ;
+    char *arg2 = (char *) 0 ;
+    char *arg3 = (char *) 0 ;
+    void *argp1 = 0 ;
+    int res1 = 0 ;
+    int res2 ;
+    char *buf2 = 0 ;
+    int alloc2 = 0 ;
+    int res3 ;
+    char *buf3 = 0 ;
+    int alloc3 = 0 ;
+    int argvi = 0;
+    bool result;
+    dXSARGS;
+    
+    if ((items < 3) || (items > 3)) {
+      SWIG_croak("Usage: Attribute_role(self,keyid,role);");
+    }
+    res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_ABAC__Attribute, 0 |  0 );
+    if (!SWIG_IsOK(res1)) {
+      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Attribute_role" "', argument " "1"" of type '" "ABAC::Attribute *""'"); 
+    }
+    arg1 = reinterpret_cast< ABAC::Attribute * >(argp1);
+    res2 = SWIG_AsCharPtrAndSize(ST(1), &buf2, NULL, &alloc2);
+    if (!SWIG_IsOK(res2)) {
+      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Attribute_role" "', argument " "2"" of type '" "char *""'");
+    }
+    arg2 = reinterpret_cast< char * >(buf2);
+    res3 = SWIG_AsCharPtrAndSize(ST(2), &buf3, NULL, &alloc3);
+    if (!SWIG_IsOK(res3)) {
+      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Attribute_role" "', argument " "3"" of type '" "char *""'");
+    }
+    arg3 = reinterpret_cast< char * >(buf3);
+    {
+      try {
+        result = (bool)(arg1)->role(arg2,arg3);
+      }
+      catch (std::invalid_argument) {
+        croak("std::invalid_argument");
+      }
+      catch (std::logic_error) {
+        croak("std::logic_error");
+      }
+    }
+    ST(argvi) = SWIG_From_bool  SWIG_PERL_CALL_ARGS_1(static_cast< bool >(result)); argvi++ ;
+    
+    if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
+    if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
+    XSRETURN(argvi);
+  fail:
+    
+    if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
+    if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
+    SWIG_croak_null();
+  }
+}
+
+
+XS(_wrap_Attribute_linking_role) {
+  {
+    ABAC::Attribute *arg1 = (ABAC::Attribute *) 0 ;
+    char *arg2 = (char *) 0 ;
+    char *arg3 = (char *) 0 ;
+    char *arg4 = (char *) 0 ;
+    void *argp1 = 0 ;
+    int res1 = 0 ;
+    int res2 ;
+    char *buf2 = 0 ;
+    int alloc2 = 0 ;
+    int res3 ;
+    char *buf3 = 0 ;
+    int alloc3 = 0 ;
+    int res4 ;
+    char *buf4 = 0 ;
+    int alloc4 = 0 ;
+    int argvi = 0;
+    bool result;
+    dXSARGS;
+    
+    if ((items < 4) || (items > 4)) {
+      SWIG_croak("Usage: Attribute_linking_role(self,keyid,role,linked);");
+    }
+    res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_ABAC__Attribute, 0 |  0 );
+    if (!SWIG_IsOK(res1)) {
+      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Attribute_linking_role" "', argument " "1"" of type '" "ABAC::Attribute *""'"); 
+    }
+    arg1 = reinterpret_cast< ABAC::Attribute * >(argp1);
+    res2 = SWIG_AsCharPtrAndSize(ST(1), &buf2, NULL, &alloc2);
+    if (!SWIG_IsOK(res2)) {
+      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Attribute_linking_role" "', argument " "2"" of type '" "char *""'");
+    }
+    arg2 = reinterpret_cast< char * >(buf2);
+    res3 = SWIG_AsCharPtrAndSize(ST(2), &buf3, NULL, &alloc3);
+    if (!SWIG_IsOK(res3)) {
+      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Attribute_linking_role" "', argument " "3"" of type '" "char *""'");
+    }
+    arg3 = reinterpret_cast< char * >(buf3);
+    res4 = SWIG_AsCharPtrAndSize(ST(3), &buf4, NULL, &alloc4);
+    if (!SWIG_IsOK(res4)) {
+      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Attribute_linking_role" "', argument " "4"" of type '" "char *""'");
+    }
+    arg4 = reinterpret_cast< char * >(buf4);
+    {
+      try {
+        result = (bool)(arg1)->linking_role(arg2,arg3,arg4);
+      }
+      catch (std::invalid_argument) {
+        croak("std::invalid_argument");
+      }
+      catch (std::logic_error) {
+        croak("std::logic_error");
+      }
+    }
+    ST(argvi) = SWIG_From_bool  SWIG_PERL_CALL_ARGS_1(static_cast< bool >(result)); argvi++ ;
+    
+    if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
+    if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
+    if (alloc4 == SWIG_NEWOBJ) delete[] buf4;
+    XSRETURN(argvi);
+  fail:
+    
+    if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
+    if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
+    if (alloc4 == SWIG_NEWOBJ) delete[] buf4;
+    SWIG_croak_null();
+  }
+}
+
+
+XS(_wrap_Attribute_bake__SWIG_0) {
+  {
+    ABAC::Attribute *arg1 = (ABAC::Attribute *) 0 ;
+    void *argp1 = 0 ;
+    int res1 = 0 ;
+    int argvi = 0;
+    bool result;
+    dXSARGS;
+    
+    if ((items < 1) || (items > 1)) {
+      SWIG_croak("Usage: Attribute_bake(self);");
+    }
+    res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_ABAC__Attribute, 0 |  0 );
+    if (!SWIG_IsOK(res1)) {
+      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Attribute_bake" "', argument " "1"" of type '" "ABAC::Attribute *""'"); 
+    }
+    arg1 = reinterpret_cast< ABAC::Attribute * >(argp1);
+    {
+      try {
+        result = (bool)(arg1)->bake();
+      }
+      catch (std::invalid_argument) {
+        croak("std::invalid_argument");
+      }
+      catch (std::logic_error) {
+        croak("std::logic_error");
+      }
+    }
+    ST(argvi) = SWIG_From_bool  SWIG_PERL_CALL_ARGS_1(static_cast< bool >(result)); argvi++ ;
+    
+    XSRETURN(argvi);
+  fail:
+    
+    SWIG_croak_null();
+  }
+}
+
+
+XS(_wrap_Attribute_bake__SWIG_1) {
+  {
+    ABAC::Attribute *arg1 = (ABAC::Attribute *) 0 ;
+    ABAC::Context *arg2 = 0 ;
+    void *argp1 = 0 ;
+    int res1 = 0 ;
+    void *argp2 = 0 ;
+    int res2 = 0 ;
+    int argvi = 0;
+    bool result;
+    dXSARGS;
+    
+    if ((items < 2) || (items > 2)) {
+      SWIG_croak("Usage: Attribute_bake(self,c);");
+    }
+    res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_ABAC__Attribute, 0 |  0 );
+    if (!SWIG_IsOK(res1)) {
+      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Attribute_bake" "', argument " "1"" of type '" "ABAC::Attribute *""'"); 
+    }
+    arg1 = reinterpret_cast< ABAC::Attribute * >(argp1);
+    res2 = SWIG_ConvertPtr(ST(1), &argp2, SWIGTYPE_p_ABAC__Context,  0 );
+    if (!SWIG_IsOK(res2)) {
+      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Attribute_bake" "', argument " "2"" of type '" "ABAC::Context &""'"); 
+    }
+    if (!argp2) {
+      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Attribute_bake" "', argument " "2"" of type '" "ABAC::Context &""'"); 
+    }
+    arg2 = reinterpret_cast< ABAC::Context * >(argp2);
+    {
+      try {
+        result = (bool)(arg1)->bake(*arg2);
+      }
+      catch (std::invalid_argument) {
+        croak("std::invalid_argument");
+      }
+      catch (std::logic_error) {
+        croak("std::logic_error");
+      }
+    }
+    ST(argvi) = SWIG_From_bool  SWIG_PERL_CALL_ARGS_1(static_cast< bool >(result)); argvi++ ;
+    
+    
+    XSRETURN(argvi);
+  fail:
+    
+    
+    SWIG_croak_null();
+  }
+}
+
+
+XS(_wrap_Attribute_bake) {
+  dXSARGS;
+  
+  {
+    unsigned long _index = 0;
+    SWIG_TypeRank _rank = 0; 
+    if (items == 1) {
+      SWIG_TypeRank _ranki = 0;
+      SWIG_TypeRank _rankm = 0;
+      SWIG_TypeRank _pi = 1;
+      int _v = 0;
+      {
+        void *vptr = 0;
+        int res = SWIG_ConvertPtr(ST(0), &vptr, SWIGTYPE_p_ABAC__Attribute, 0);
+        _v = SWIG_CheckState(res);
+      }
+      if (!_v) goto check_1;
+      _ranki += _v*_pi;
+      _rankm += _pi;
+      _pi *= SWIG_MAXCASTRANK;
+      if (!_index || (_ranki < _rank)) {
+        _rank = _ranki; _index = 1;
+        if (_rank == _rankm) goto dispatch;
+      }
+    }
+  check_1:
+    
+    if (items == 2) {
+      SWIG_TypeRank _ranki = 0;
+      SWIG_TypeRank _rankm = 0;
+      SWIG_TypeRank _pi = 1;
+      int _v = 0;
+      {
+        void *vptr = 0;
+        int res = SWIG_ConvertPtr(ST(0), &vptr, SWIGTYPE_p_ABAC__Attribute, 0);
+        _v = SWIG_CheckState(res);
+      }
+      if (!_v) goto check_2;
+      _ranki += _v*_pi;
+      _rankm += _pi;
+      _pi *= SWIG_MAXCASTRANK;
+      {
+        void *vptr = 0;
+        int res = SWIG_ConvertPtr(ST(1), &vptr, SWIGTYPE_p_ABAC__Context, 0);
+        _v = SWIG_CheckState(res);
+      }
+      if (!_v) goto check_2;
+      _ranki += _v*_pi;
+      _rankm += _pi;
+      _pi *= SWIG_MAXCASTRANK;
+      if (!_index || (_ranki < _rank)) {
+        _rank = _ranki; _index = 2;
+        if (_rank == _rankm) goto dispatch;
+      }
+    }
+  check_2:
+    
+  dispatch:
+    switch(_index) {
+    case 1:
+      PUSHMARK(MARK); SWIG_CALLXS(_wrap_Attribute_bake__SWIG_0); return;
+    case 2:
+      PUSHMARK(MARK); SWIG_CALLXS(_wrap_Attribute_bake__SWIG_1); return;
+    }
+  }
+  
+  croak("No matching function for overloaded 'Attribute_bake'");
+  XSRETURN(0);
+}
+
+
+XS(_wrap_Attribute_baked) {
+  {
+    ABAC::Attribute *arg1 = (ABAC::Attribute *) 0 ;
+    void *argp1 = 0 ;
+    int res1 = 0 ;
+    int argvi = 0;
+    bool result;
+    dXSARGS;
+    
+    if ((items < 1) || (items > 1)) {
+      SWIG_croak("Usage: Attribute_baked(self);");
+    }
+    res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_ABAC__Attribute, 0 |  0 );
+    if (!SWIG_IsOK(res1)) {
+      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Attribute_baked" "', argument " "1"" of type '" "ABAC::Attribute *""'"); 
+    }
+    arg1 = reinterpret_cast< ABAC::Attribute * >(argp1);
+    {
+      try {
+        result = (bool)(arg1)->baked();
+      }
+      catch (std::invalid_argument) {
+        croak("std::invalid_argument");
+      }
+      catch (std::logic_error) {
+        croak("std::logic_error");
+      }
+    }
+    ST(argvi) = SWIG_From_bool  SWIG_PERL_CALL_ARGS_1(static_cast< bool >(result)); argvi++ ;
+    
+    XSRETURN(argvi);
+  fail:
+    
+    SWIG_croak_null();
+  }
+}
+
+
+XS(_wrap_Attribute_set_output_format) {
+  {
+    ABAC::Attribute *arg1 = (ABAC::Attribute *) 0 ;
+    char *arg2 = (char *) 0 ;
+    void *argp1 = 0 ;
+    int res1 = 0 ;
+    int res2 ;
+    char *buf2 = 0 ;
+    int alloc2 = 0 ;
+    int argvi = 0;
+    dXSARGS;
+    
+    if ((items < 2) || (items > 2)) {
+      SWIG_croak("Usage: Attribute_set_output_format(self,fmt);");
+    }
+    res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_ABAC__Attribute, 0 |  0 );
+    if (!SWIG_IsOK(res1)) {
+      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Attribute_set_output_format" "', argument " "1"" of type '" "ABAC::Attribute *""'"); 
+    }
+    arg1 = reinterpret_cast< ABAC::Attribute * >(argp1);
+    res2 = SWIG_AsCharPtrAndSize(ST(1), &buf2, NULL, &alloc2);
+    if (!SWIG_IsOK(res2)) {
+      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Attribute_set_output_format" "', argument " "2"" of type '" "char *""'");
+    }
+    arg2 = reinterpret_cast< char * >(buf2);
+    {
+      try {
+        (arg1)->set_output_format(arg2);
+      }
+      catch (std::invalid_argument) {
+        croak("std::invalid_argument");
+      }
+      catch (std::logic_error) {
+        croak("std::logic_error");
+      }
+    }
+    ST(argvi) = sv_newmortal();
+    
+    if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
+    XSRETURN(argvi);
+  fail:
+    
+    if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
+    SWIG_croak_null();
+  }
+}
+
+
+XS(_wrap_Attribute_get_output_format) {
+  {
+    ABAC::Attribute *arg1 = (ABAC::Attribute *) 0 ;
+    void *argp1 = 0 ;
+    int res1 = 0 ;
+    int argvi = 0;
+    char *result = 0 ;
+    dXSARGS;
+    
+    if ((items < 1) || (items > 1)) {
+      SWIG_croak("Usage: Attribute_get_output_format(self);");
+    }
+    res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_ABAC__Attribute, 0 |  0 );
+    if (!SWIG_IsOK(res1)) {
+      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Attribute_get_output_format" "', argument " "1"" of type '" "ABAC::Attribute *""'"); 
+    }
+    arg1 = reinterpret_cast< ABAC::Attribute * >(argp1);
+    {
+      try {
+        result = (char *)(arg1)->get_output_format();
+      }
+      catch (std::invalid_argument) {
+        croak("std::invalid_argument");
+      }
+      catch (std::logic_error) {
+        croak("std::logic_error");
+      }
+    }
+    ST(argvi) = SWIG_FromCharPtr((const char *)result); argvi++ ;
+    
+    XSRETURN(argvi);
+  fail:
+    
+    SWIG_croak_null();
+  }
+}
+
+
+XS(_wrap_Attribute_write) {
+  {
+    ABAC::Attribute *arg1 = (ABAC::Attribute *) 0 ;
+    FILE *arg2 = (FILE *) 0 ;
+    void *argp1 = 0 ;
+    int res1 = 0 ;
+    void *argp2 = 0 ;
+    int res2 = 0 ;
+    int argvi = 0;
+    dXSARGS;
+    
+    if ((items < 2) || (items > 2)) {
+      SWIG_croak("Usage: Attribute_write(self,out);");
+    }
+    res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_ABAC__Attribute, 0 |  0 );
+    if (!SWIG_IsOK(res1)) {
+      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Attribute_write" "', argument " "1"" of type '" "ABAC::Attribute *""'"); 
+    }
+    arg1 = reinterpret_cast< ABAC::Attribute * >(argp1);
+    res2 = SWIG_ConvertPtr(ST(1), &argp2,SWIGTYPE_p_FILE, 0 |  0 );
+    if (!SWIG_IsOK(res2)) {
+      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Attribute_write" "', argument " "2"" of type '" "FILE *""'"); 
+    }
+    arg2 = reinterpret_cast< FILE * >(argp2);
+    {
+      try {
+        (arg1)->write(arg2);
+      }
+      catch (std::invalid_argument) {
+        croak("std::invalid_argument");
+      }
+      catch (std::logic_error) {
+        croak("std::logic_error");
+      }
+    }
+    ST(argvi) = sv_newmortal();
+    
+    
+    XSRETURN(argvi);
+  fail:
+    
+    
+    SWIG_croak_null();
+  }
+}
+
+
+XS(_wrap_Attribute_write_file) {
+  {
+    ABAC::Attribute *arg1 = (ABAC::Attribute *) 0 ;
+    char *arg2 = (char *) 0 ;
+    void *argp1 = 0 ;
+    int res1 = 0 ;
+    int res2 ;
+    char *buf2 = 0 ;
+    int alloc2 = 0 ;
+    int argvi = 0;
+    dXSARGS;
+    
+    if ((items < 2) || (items > 2)) {
+      SWIG_croak("Usage: Attribute_write_file(self,name);");
+    }
+    res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_ABAC__Attribute, 0 |  0 );
+    if (!SWIG_IsOK(res1)) {
+      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Attribute_write_file" "', argument " "1"" of type '" "ABAC::Attribute *""'"); 
+    }
+    arg1 = reinterpret_cast< ABAC::Attribute * >(argp1);
+    res2 = SWIG_AsCharPtrAndSize(ST(1), &buf2, NULL, &alloc2);
+    if (!SWIG_IsOK(res2)) {
+      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Attribute_write_file" "', argument " "2"" of type '" "char const *""'");
+    }
+    arg2 = reinterpret_cast< char * >(buf2);
+    {
+      try {
+        (arg1)->write_file((char const *)arg2);
+      }
+      catch (std::invalid_argument) {
+        croak("std::invalid_argument");
+      }
+      catch (std::logic_error) {
+        croak("std::logic_error");
+      }
+    }
+    ST(argvi) = sv_newmortal();
+    
+    if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
+    XSRETURN(argvi);
+  fail:
+    
+    if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
+    SWIG_croak_null();
+  }
+}
+
+
+XS(_wrap_Attribute_write_name) {
+  {
+    ABAC::Attribute *arg1 = (ABAC::Attribute *) 0 ;
+    char *arg2 = (char *) 0 ;
+    void *argp1 = 0 ;
+    int res1 = 0 ;
+    int res2 ;
+    char *buf2 = 0 ;
+    int alloc2 = 0 ;
+    int argvi = 0;
+    dXSARGS;
+    
+    if ((items < 2) || (items > 2)) {
+      SWIG_croak("Usage: Attribute_write_name(self,name);");
+    }
+    res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_ABAC__Attribute, 0 |  0 );
+    if (!SWIG_IsOK(res1)) {
+      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Attribute_write_name" "', argument " "1"" of type '" "ABAC::Attribute *""'"); 
+    }
+    arg1 = reinterpret_cast< ABAC::Attribute * >(argp1);
+    res2 = SWIG_AsCharPtrAndSize(ST(1), &buf2, NULL, &alloc2);
+    if (!SWIG_IsOK(res2)) {
+      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Attribute_write_name" "', argument " "2"" of type '" "char const *""'");
+    }
+    arg2 = reinterpret_cast< char * >(buf2);
+    {
+      try {
+        (arg1)->write_name((char const *)arg2);
+      }
+      catch (std::invalid_argument) {
+        croak("std::invalid_argument");
+      }
+      catch (std::logic_error) {
+        croak("std::logic_error");
+      }
+    }
+    ST(argvi) = sv_newmortal();
+    
+    if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
+    XSRETURN(argvi);
+  fail:
+    
+    if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
+    SWIG_croak_null();
+  }
+}
+
+
+XS(_wrap_Attribute_cert_chunk) {
+  {
+    ABAC::Attribute *arg1 = (ABAC::Attribute *) 0 ;
+    void *argp1 = 0 ;
+    int res1 = 0 ;
+    int argvi = 0;
+    abac_chunk_t result;
+    dXSARGS;
+    
+    if ((items < 1) || (items > 1)) {
+      SWIG_croak("Usage: Attribute_cert_chunk(self);");
+    }
+    res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_ABAC__Attribute, 0 |  0 );
+    if (!SWIG_IsOK(res1)) {
+      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Attribute_cert_chunk" "', argument " "1"" of type '" "ABAC::Attribute *""'"); 
+    }
+    arg1 = reinterpret_cast< ABAC::Attribute * >(argp1);
+    {
+      try {
+        result = (arg1)->cert_chunk();
+      }
+      catch (std::invalid_argument) {
+        croak("std::invalid_argument");
+      }
+      catch (std::logic_error) {
+        croak("std::logic_error");
+      }
+    }
+    {
+      ST(argvi) = newSVpvn(
+        (const char *)(&result)->ptr,
+        (&result)->len
+        );
+      ++argvi;
+    }
+    
+    XSRETURN(argvi);
+  fail:
+    
+    SWIG_croak_null();
+  }
+}
+
+
+
+/* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
+
+static swig_type_info _swigt__p_ABAC__Attribute = {"_p_ABAC__Attribute", "ABAC::Attribute *", 0, 0, (void*)"ABAC::Attribute", 0};
+static swig_type_info _swigt__p_ABAC__Context = {"_p_ABAC__Context", "ABAC::Context *", 0, 0, (void*)"ABAC::Context", 0};
+static swig_type_info _swigt__p_ABAC__Credential = {"_p_ABAC__Credential", "ABAC::Credential *", 0, 0, (void*)"ABAC::Credential", 0};
+static swig_type_info _swigt__p_ABAC__ID = {"_p_ABAC__ID", "ABAC::ID *", 0, 0, (void*)"ABAC::ID", 0};
+static swig_type_info _swigt__p_ABAC__Role = {"_p_ABAC__Role", "ABAC::Role *", 0, 0, (void*)"ABAC::Role", 0};
+static swig_type_info _swigt__p_FILE = {"_p_FILE", "FILE *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p__abac_attribute_t = {"_p__abac_attribute_t", "_abac_attribute_t *|abac_attribute_t *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p__abac_chunk_t = {"_p__abac_chunk_t", "_abac_chunk_t *|abac_chunk_t *", 0, 0, (void*)"ABAC::abac_chunk_t", 0};
+static swig_type_info _swigt__p__abac_context_t = {"_p__abac_context_t", "_abac_context_t *|abac_context_t *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p__abac_credential_t = {"_p__abac_credential_t", "_abac_credential_t *|abac_credential_t *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p__abac_id_cert_t = {"_p__abac_id_cert_t", "_abac_id_cert_t *|abac_id_cert_t *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p__abac_id_t = {"_p__abac_id_t", "_abac_id_t *|abac_id_t *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p__abac_list_t = {"_p__abac_list_t", "ABAC_LIST_T *|_abac_list_t *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p__abac_role_t = {"_p__abac_role_t", "_abac_role_t *|abac_role_t *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_abac_keyid_map_t = {"_p_abac_keyid_map_t", "abac_keyid_map_t *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_abac_keyid_mapping_t = {"_p_abac_keyid_mapping_t", "abac_keyid_mapping_t *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_bool = {"_p_bool", "bool *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_char = {"_p_char", "char *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_int = {"_p_int", "int *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_p__abac_attribute_t = {"_p_p__abac_attribute_t", "_abac_attribute_t **|abac_attribute_t **", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_p__abac_credential_t = {"_p_p__abac_credential_t", "_abac_credential_t **|abac_credential_t **", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_p__abac_id_cert_t = {"_p_p__abac_id_cert_t", "_abac_id_cert_t **|abac_id_cert_t **", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_p__abac_id_t = {"_p_p__abac_id_t", "_abac_id_t **|abac_id_t **", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_size_type = {"_p_size_type", "size_type *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_std__out_of_range = {"_p_std__out_of_range", "std::out_of_range *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_std__vectorT_ABAC__Credential_t = {"_p_std__vectorT_ABAC__Credential_t", "std::vector< ABAC::Credential > *", 0, 0, (void*)"ABAC::CredentialVector", 0};
+static swig_type_info _swigt__p_tm = {"_p_tm", "tm *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_unsigned_char = {"_p_unsigned_char", "unsigned char *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_value_type = {"_p_value_type", "value_type *", 0, 0, (void*)0, 0};
+
+static swig_type_info *swig_type_initial[] = {
+  &_swigt__p_ABAC__Attribute,
+  &_swigt__p_ABAC__Context,
+  &_swigt__p_ABAC__Credential,
+  &_swigt__p_ABAC__ID,
+  &_swigt__p_ABAC__Role,
+  &_swigt__p_FILE,
+  &_swigt__p__abac_attribute_t,
+  &_swigt__p__abac_chunk_t,
+  &_swigt__p__abac_context_t,
+  &_swigt__p__abac_credential_t,
+  &_swigt__p__abac_id_cert_t,
+  &_swigt__p__abac_id_t,
+  &_swigt__p__abac_list_t,
+  &_swigt__p__abac_role_t,
+  &_swigt__p_abac_keyid_map_t,
+  &_swigt__p_abac_keyid_mapping_t,
+  &_swigt__p_bool,
+  &_swigt__p_char,
+  &_swigt__p_int,
+  &_swigt__p_p__abac_attribute_t,
+  &_swigt__p_p__abac_credential_t,
+  &_swigt__p_p__abac_id_cert_t,
+  &_swigt__p_p__abac_id_t,
+  &_swigt__p_size_type,
+  &_swigt__p_std__out_of_range,
+  &_swigt__p_std__vectorT_ABAC__Credential_t,
+  &_swigt__p_tm,
+  &_swigt__p_unsigned_char,
+  &_swigt__p_value_type,
+};
+
+static swig_cast_info _swigc__p_ABAC__Attribute[] = {  {&_swigt__p_ABAC__Attribute, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_ABAC__Context[] = {  {&_swigt__p_ABAC__Context, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_ABAC__Credential[] = {  {&_swigt__p_ABAC__Credential, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_ABAC__ID[] = {  {&_swigt__p_ABAC__ID, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_ABAC__Role[] = {  {&_swigt__p_ABAC__Role, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FILE[] = {  {&_swigt__p_FILE, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p__abac_attribute_t[] = {  {&_swigt__p__abac_attribute_t, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p__abac_chunk_t[] = {  {&_swigt__p__abac_chunk_t, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p__abac_context_t[] = {  {&_swigt__p__abac_context_t, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p__abac_credential_t[] = {  {&_swigt__p__abac_credential_t, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p__abac_id_cert_t[] = {  {&_swigt__p__abac_id_cert_t, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p__abac_id_t[] = {  {&_swigt__p__abac_id_t, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p__abac_list_t[] = {  {&_swigt__p__abac_list_t, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p__abac_role_t[] = {  {&_swigt__p__abac_role_t, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_abac_keyid_map_t[] = {  {&_swigt__p_abac_keyid_map_t, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_abac_keyid_mapping_t[] = {  {&_swigt__p_abac_keyid_mapping_t, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_bool[] = {  {&_swigt__p_bool, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_char[] = {  {&_swigt__p_char, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_int[] = {  {&_swigt__p_int, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_p__abac_attribute_t[] = {  {&_swigt__p_p__abac_attribute_t, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_p__abac_credential_t[] = {  {&_swigt__p_p__abac_credential_t, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_p__abac_id_cert_t[] = {  {&_swigt__p_p__abac_id_cert_t, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_p__abac_id_t[] = {  {&_swigt__p_p__abac_id_t, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_size_type[] = {  {&_swigt__p_size_type, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_std__out_of_range[] = {  {&_swigt__p_std__out_of_range, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_std__vectorT_ABAC__Credential_t[] = {  {&_swigt__p_std__vectorT_ABAC__Credential_t, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_tm[] = {  {&_swigt__p_tm, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_unsigned_char[] = {  {&_swigt__p_unsigned_char, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_value_type[] = {  {&_swigt__p_value_type, 0, 0, 0},{0, 0, 0, 0}};
+
+static swig_cast_info *swig_cast_initial[] = {
+  _swigc__p_ABAC__Attribute,
+  _swigc__p_ABAC__Context,
+  _swigc__p_ABAC__Credential,
+  _swigc__p_ABAC__ID,
+  _swigc__p_ABAC__Role,
+  _swigc__p_FILE,
+  _swigc__p__abac_attribute_t,
+  _swigc__p__abac_chunk_t,
+  _swigc__p__abac_context_t,
+  _swigc__p__abac_credential_t,
+  _swigc__p__abac_id_cert_t,
+  _swigc__p__abac_id_t,
+  _swigc__p__abac_list_t,
+  _swigc__p__abac_role_t,
+  _swigc__p_abac_keyid_map_t,
+  _swigc__p_abac_keyid_mapping_t,
+  _swigc__p_bool,
+  _swigc__p_char,
+  _swigc__p_int,
+  _swigc__p_p__abac_attribute_t,
+  _swigc__p_p__abac_credential_t,
+  _swigc__p_p__abac_id_cert_t,
+  _swigc__p_p__abac_id_t,
+  _swigc__p_size_type,
+  _swigc__p_std__out_of_range,
+  _swigc__p_std__vectorT_ABAC__Credential_t,
+  _swigc__p_tm,
+  _swigc__p_unsigned_char,
+  _swigc__p_value_type,
+};
+
+
+/* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */
+
+static swig_constant_info swig_constants[] = {
+{0,0,0,0,0,0}
+};
+#ifdef __cplusplus
+}
+#endif
+static swig_variable_info swig_variables[] = {
+{0,0,0,0}
+};
+static swig_command_info swig_commands[] = {
+{"ABACc::SSL_keyid", _wrap_SSL_keyid},
+{"ABACc::new_CredentialVector", _wrap_new_CredentialVector},
+{"ABACc::CredentialVector_size", _wrap_CredentialVector_size},
+{"ABACc::CredentialVector_empty", _wrap_CredentialVector_empty},
+{"ABACc::CredentialVector_clear", _wrap_CredentialVector_clear},
+{"ABACc::CredentialVector_push", _wrap_CredentialVector_push},
+{"ABACc::CredentialVector_get", _wrap_CredentialVector_get},
+{"ABACc::CredentialVector_set", _wrap_CredentialVector_set},
+{"ABACc::delete_CredentialVector", _wrap_delete_CredentialVector},
+{"ABACc::abac_chunk_t_ptr_set", _wrap_abac_chunk_t_ptr_set},
+{"ABACc::abac_chunk_t_ptr_get", _wrap_abac_chunk_t_ptr_get},
+{"ABACc::abac_chunk_t_len_set", _wrap_abac_chunk_t_len_set},
+{"ABACc::abac_chunk_t_len_get", _wrap_abac_chunk_t_len_get},
+{"ABACc::new_abac_chunk_t", _wrap_new_abac_chunk_t},
+{"ABACc::delete_abac_chunk_t", _wrap_delete_abac_chunk_t},
+{"ABACc::abac_chunk_free", _wrap_abac_chunk_free},
+{"ABACc::abac_context_new", _wrap_abac_context_new},
+{"ABACc::abac_context_dup", _wrap_abac_context_dup},
+{"ABACc::abac_context_free", _wrap_abac_context_free},
+{"ABACc::abac_context_load_id_file", _wrap_abac_context_load_id_file},
+{"ABACc::abac_context_load_id_chunk", _wrap_abac_context_load_id_chunk},
+{"ABACc::abac_context_load_id_id", _wrap_abac_context_load_id_id},
+{"ABACc::abac_context_load_attribute_file", _wrap_abac_context_load_attribute_file},
+{"ABACc::abac_context_load_attribute_chunk", _wrap_abac_context_load_attribute_chunk},
+{"ABACc::abac_context_load_directory", _wrap_abac_context_load_directory},
+{"ABACc::abac_context_query", _wrap_abac_context_query},
+{"ABACc::abac_context_credentials", _wrap_abac_context_credentials},
+{"ABACc::abac_context_principals", _wrap_abac_context_principals},
+{"ABACc::abac_context_id_credentials_free", _wrap_abac_context_id_credentials_free},
+{"ABACc::abac_context_credentials_free", _wrap_abac_context_credentials_free},
+{"ABACc::abac_context_set_nickname", _wrap_abac_context_set_nickname},
+{"ABACc::abac_context_expand_key", _wrap_abac_context_expand_key},
+{"ABACc::abac_context_expand_nickname", _wrap_abac_context_expand_nickname},
+{"ABACc::abac_context_get_keyid_map", _wrap_abac_context_get_keyid_map},
+{"ABACc::abac_credential_head", _wrap_abac_credential_head},
+{"ABACc::abac_credential_tail", _wrap_abac_credential_tail},
+{"ABACc::abac_credential_attribute_cert", _wrap_abac_credential_attribute_cert},
+{"ABACc::abac_credential_issuer_cert", _wrap_abac_credential_issuer_cert},
+{"ABACc::abac_credential_dup", _wrap_abac_credential_dup},
+{"ABACc::abac_credential_free", _wrap_abac_credential_free},
+{"ABACc::abac_id_cert_keyid", _wrap_abac_id_cert_keyid},
+{"ABACc::abac_id_cert_cn", _wrap_abac_id_cert_cn},
+{"ABACc::abac_role_principal_new", _wrap_abac_role_principal_new},
+{"ABACc::abac_role_role_new", _wrap_abac_role_role_new},
+{"ABACc::abac_role_linking_new", _wrap_abac_role_linking_new},
+{"ABACc::abac_role_free", _wrap_abac_role_free},
+{"ABACc::abac_role_from_string", _wrap_abac_role_from_string},
+{"ABACc::abac_role_dup", _wrap_abac_role_dup},
+{"ABACc::abac_role_is_principal", _wrap_abac_role_is_principal},
+{"ABACc::abac_role_is_role", _wrap_abac_role_is_role},
+{"ABACc::abac_role_is_linking", _wrap_abac_role_is_linking},
+{"ABACc::abac_role_is_intersection", _wrap_abac_role_is_intersection},
+{"ABACc::abac_role_string", _wrap_abac_role_string},
+{"ABACc::abac_role_short_string", _wrap_abac_role_short_string},
+{"ABACc::abac_role_linked_role", _wrap_abac_role_linked_role},
+{"ABACc::abac_role_linking_role", _wrap_abac_role_linking_role},
+{"ABACc::abac_role_role_name", _wrap_abac_role_role_name},
+{"ABACc::abac_role_principal", _wrap_abac_role_principal},
+{"ABACc::abac_role_attr_key", _wrap_abac_role_attr_key},
+{"ABACc::abac_id_from_file", _wrap_abac_id_from_file},
+{"ABACc::abac_id_from_chunk", _wrap_abac_id_from_chunk},
+{"ABACc::abac_id_privkey_from_file", _wrap_abac_id_privkey_from_file},
+{"ABACc::abac_id_privkey_from_chunk", _wrap_abac_id_privkey_from_chunk},
+{"ABACc::abac_id_generate", _wrap_abac_id_generate},
+{"ABACc::abac_id_generate_with_key", _wrap_abac_id_generate_with_key},
+{"ABACc::abac_id_keyid", _wrap_abac_id_keyid},
+{"ABACc::abac_id_cn", _wrap_abac_id_cn},
+{"ABACc::abac_id_issuer", _wrap_abac_id_issuer},
+{"ABACc::abac_id_subject", _wrap_abac_id_subject},
+{"ABACc::abac_id_still_valid", _wrap_abac_id_still_valid},
+{"ABACc::abac_id_has_keyid", _wrap_abac_id_has_keyid},
+{"ABACc::abac_id_has_privkey", _wrap_abac_id_has_privkey},
+{"ABACc::abac_id_validity", _wrap_abac_id_validity},
+{"ABACc::abac_id_cert_filename", _wrap_abac_id_cert_filename},
+{"ABACc::abac_id_write_cert", _wrap_abac_id_write_cert},
+{"ABACc::abac_id_privkey_filename", _wrap_abac_id_privkey_filename},
+{"ABACc::abac_id_write_privkey", _wrap_abac_id_write_privkey},
+{"ABACc::abac_id_cert_chunk", _wrap_abac_id_cert_chunk},
+{"ABACc::abac_id_privkey_chunk", _wrap_abac_id_privkey_chunk},
+{"ABACc::abac_id_dup", _wrap_abac_id_dup},
+{"ABACc::abac_id_free", _wrap_abac_id_free},
+{"ABACc::abac_attribute_create", _wrap_abac_attribute_create},
+{"ABACc::abac_attribute_set_head", _wrap_abac_attribute_set_head},
+{"ABACc::abac_attribute_get_head", _wrap_abac_attribute_get_head},
+{"ABACc::abac_attribute_principal", _wrap_abac_attribute_principal},
+{"ABACc::abac_attribute_role", _wrap_abac_attribute_role},
+{"ABACc::abac_attribute_linking_role", _wrap_abac_attribute_linking_role},
+{"ABACc::abac_attribute_bake", _wrap_abac_attribute_bake},
+{"ABACc::abac_attribute_bake_context", _wrap_abac_attribute_bake_context},
+{"ABACc::abac_attribute_baked", _wrap_abac_attribute_baked},
+{"ABACc::abac_attribute_write", _wrap_abac_attribute_write},
+{"ABACc::abac_attribute_write_file", _wrap_abac_attribute_write_file},
+{"ABACc::abac_attribute_get_ntails", _wrap_abac_attribute_get_ntails},
+{"ABACc::abac_attribute_get_tail_n", _wrap_abac_attribute_get_tail_n},
+{"ABACc::abac_attribute_cert_chunk", _wrap_abac_attribute_cert_chunk},
+{"ABACc::abac_attribute_free", _wrap_abac_attribute_free},
+{"ABACc::abac_attribute_certs_from_file", _wrap_abac_attribute_certs_from_file},
+{"ABACc::abac_attribute_certs_from_chunk", _wrap_abac_attribute_certs_from_chunk},
+{"ABACc::abac_attribute_role_string", _wrap_abac_attribute_role_string},
+{"ABACc::abac_attribute_issuer_id", _wrap_abac_attribute_issuer_id},
+{"ABACc::abac_attribute_get_output_format", _wrap_abac_attribute_get_output_format},
+{"ABACc::abac_attribute_set_output_format", _wrap_abac_attribute_set_output_format},
+{"ABACc::abac_attribute_validity", _wrap_abac_attribute_validity},
+{"ABACc::abac_attribute_get_keyid_map", _wrap_abac_attribute_get_keyid_map},
+{"ABACc::abac_attribute_get_principal", _wrap_abac_attribute_get_principal},
+{"ABACc::abac_attribute_still_valid", _wrap_abac_attribute_still_valid},
+{"ABACc::abac_keyid_mapping_new", _wrap_abac_keyid_mapping_new},
+{"ABACc::abac_keyid_mapping_free", _wrap_abac_keyid_mapping_free},
+{"ABACc::abac_keyid_map_new", _wrap_abac_keyid_map_new},
+{"ABACc::abac_keyid_map_dup", _wrap_abac_keyid_map_dup},
+{"ABACc::abac_keyid_map_clone", _wrap_abac_keyid_map_clone},
+{"ABACc::abac_keyid_map_free", _wrap_abac_keyid_map_free},
+{"ABACc::abac_keyid_map_key_to_nickname", _wrap_abac_keyid_map_key_to_nickname},
+{"ABACc::abac_keyid_map_nickname_to_key", _wrap_abac_keyid_map_nickname_to_key},
+{"ABACc::abac_keyid_map_remove_keyid", _wrap_abac_keyid_map_remove_keyid},
+{"ABACc::abac_keyid_map_add_nickname", _wrap_abac_keyid_map_add_nickname},
+{"ABACc::abac_keyid_map_merge", _wrap_abac_keyid_map_merge},
+{"ABACc::abac_keyid_map_expand_key", _wrap_abac_keyid_map_expand_key},
+{"ABACc::abac_keyid_map_expand_nickname", _wrap_abac_keyid_map_expand_nickname},
+{"ABACc::new_Context", _wrap_new_Context},
+{"ABACc::delete_Context", _wrap_delete_Context},
+{"ABACc::Context_load_id_file", _wrap_Context_load_id_file},
+{"ABACc::Context_load_id_chunk", _wrap_Context_load_id_chunk},
+{"ABACc::Context_load_id_id", _wrap_Context_load_id_id},
+{"ABACc::Context_load_attribute_file", _wrap_Context_load_attribute_file},
+{"ABACc::Context_load_attribute_chunk", _wrap_Context_load_attribute_chunk},
+{"ABACc::Context_query", _wrap_Context_query},
+{"ABACc::Context_credentials", _wrap_Context_credentials},
+{"ABACc::Context_load_directory", _wrap_Context_load_directory},
+{"ABACc::Context_set_nickname", _wrap_Context_set_nickname},
+{"ABACc::new_Role", _wrap_new_Role},
+{"ABACc::delete_Role", _wrap_delete_Role},
+{"ABACc::Role_is_principal", _wrap_Role_is_principal},
+{"ABACc::Role_is_role", _wrap_Role_is_role},
+{"ABACc::Role_is_linking", _wrap_Role_is_linking},
+{"ABACc::Role_string", _wrap_Role_string},
+{"ABACc::Role_short_string", _wrap_Role_short_string},
+{"ABACc::Role_linked_role", _wrap_Role_linked_role},
+{"ABACc::Role_role_name", _wrap_Role_role_name},
+{"ABACc::Role_principal", _wrap_Role_principal},
+{"ABACc::new_Credential", _wrap_new_Credential},
+{"ABACc::delete_Credential", _wrap_delete_Credential},
+{"ABACc::Credential_head", _wrap_Credential_head},
+{"ABACc::Credential_tail", _wrap_Credential_tail},
+{"ABACc::Credential_attribute_cert", _wrap_Credential_attribute_cert},
+{"ABACc::Credential_issuer_cert", _wrap_Credential_issuer_cert},
+{"ABACc::delete_ID", _wrap_delete_ID},
+{"ABACc::new_ID_chunk", _wrap_new_ID_chunk},
+{"ABACc::new_ID", _wrap_new_ID},
+{"ABACc::ID_load_privkey", _wrap_ID_load_privkey},
+{"ABACc::ID_load_privkey_chunk", _wrap_ID_load_privkey_chunk},
+{"ABACc::ID_has_privkey", _wrap_ID_has_privkey},
+{"ABACc::ID_keyid", _wrap_ID_keyid},
+{"ABACc::ID_cn", _wrap_ID_cn},
+{"ABACc::ID_cert_filename", _wrap_ID_cert_filename},
+{"ABACc::ID_write_cert", _wrap_ID_write_cert},
+{"ABACc::ID_write_cert_file", _wrap_ID_write_cert_file},
+{"ABACc::ID_write_cert_name", _wrap_ID_write_cert_name},
+{"ABACc::ID_privkey_filename", _wrap_ID_privkey_filename},
+{"ABACc::ID_write_privkey", _wrap_ID_write_privkey},
+{"ABACc::ID_write_privkey_file", _wrap_ID_write_privkey_file},
+{"ABACc::ID_write_privkey_name", _wrap_ID_write_privkey_name},
+{"ABACc::ID_cert_chunk", _wrap_ID_cert_chunk},
+{"ABACc::ID_privkey_chunk", _wrap_ID_privkey_chunk},
+{"ABACc::delete_Attribute", _wrap_delete_Attribute},
+{"ABACc::new_Attribute", _wrap_new_Attribute},
+{"ABACc::Attribute_principal", _wrap_Attribute_principal},
+{"ABACc::Attribute_role", _wrap_Attribute_role},
+{"ABACc::Attribute_linking_role", _wrap_Attribute_linking_role},
+{"ABACc::Attribute_bake", _wrap_Attribute_bake},
+{"ABACc::Attribute_baked", _wrap_Attribute_baked},
+{"ABACc::Attribute_set_output_format", _wrap_Attribute_set_output_format},
+{"ABACc::Attribute_get_output_format", _wrap_Attribute_get_output_format},
+{"ABACc::Attribute_write", _wrap_Attribute_write},
+{"ABACc::Attribute_write_file", _wrap_Attribute_write_file},
+{"ABACc::Attribute_write_name", _wrap_Attribute_write_name},
+{"ABACc::Attribute_cert_chunk", _wrap_Attribute_cert_chunk},
+{0,0}
+};
+/* -----------------------------------------------------------------------------
+ * Type initialization:
+ * This problem is tough by the requirement that no dynamic
+ * memory is used. Also, since swig_type_info structures store pointers to
+ * swig_cast_info structures and swig_cast_info structures store pointers back
+ * to swig_type_info structures, we need some lookup code at initialization.
+ * The idea is that swig generates all the structures that are needed.
+ * The runtime then collects these partially filled structures.
+ * The SWIG_InitializeModule function takes these initial arrays out of
+ * swig_module, and does all the lookup, filling in the swig_module.types
+ * array with the correct data and linking the correct swig_cast_info
+ * structures together.
+ *
+ * The generated swig_type_info structures are assigned statically to an initial
+ * array. We just loop through that array, and handle each type individually.
+ * First we lookup if this type has been already loaded, and if so, use the
+ * loaded structure instead of the generated one. Then we have to fill in the
+ * cast linked list. The cast data is initially stored in something like a
+ * two-dimensional array. Each row corresponds to a type (there are the same
+ * number of rows as there are in the swig_type_initial array). Each entry in
+ * a column is one of the swig_cast_info structures for that type.
+ * The cast_initial array is actually an array of arrays, because each row has
+ * a variable number of columns. So to actually build the cast linked list,
+ * we find the array of casts associated with the type, and loop through it
+ * adding the casts to the list. The one last trick we need to do is making
+ * sure the type pointer in the swig_cast_info struct is correct.
+ *
+ * First off, we lookup the cast->type name to see if it is already loaded.
+ * There are three cases to handle:
+ *  1) If the cast->type has already been loaded AND the type we are adding
+ *     casting info to has not been loaded (it is in this module), THEN we
+ *     replace the cast->type pointer with the type pointer that has already
+ *     been loaded.
+ *  2) If BOTH types (the one we are adding casting info to, and the
+ *     cast->type) are loaded, THEN the cast info has already been loaded by
+ *     the previous module so we just ignore it.
+ *  3) Finally, if cast->type has not already been loaded, then we add that
+ *     swig_cast_info to the linked list (because the cast->type) pointer will
+ *     be correct.
+ * ----------------------------------------------------------------------------- */
+
+#ifdef __cplusplus
+extern "C" {
+#if 0
+} /* c-mode */
+#endif
+#endif
+
+#if 0
+#define SWIGRUNTIME_DEBUG
+#endif
+
+
+SWIGRUNTIME void
+SWIG_InitializeModule(void *clientdata) {
+  size_t i;
+  swig_module_info *module_head, *iter;
+  int init;
+  
+  /* check to see if the circular list has been setup, if not, set it up */
+  if (swig_module.next==0) {
+    /* Initialize the swig_module */
+    swig_module.type_initial = swig_type_initial;
+    swig_module.cast_initial = swig_cast_initial;
+    swig_module.next = &swig_module;
+    init = 1;
+  } else {
+    init = 0;
+  }
+  
+  /* Try and load any already created modules */
+  module_head = SWIG_GetModule(clientdata);
+  if (!module_head) {
+    /* This is the first module loaded for this interpreter */
+    /* so set the swig module into the interpreter */
+    SWIG_SetModule(clientdata, &swig_module);
+  } else {
+    /* the interpreter has loaded a SWIG module, but has it loaded this one? */
+    iter=module_head;
+    do {
+      if (iter==&swig_module) {
+        /* Our module is already in the list, so there's nothing more to do. */
+        return;
+      }
+      iter=iter->next;
+    } while (iter!= module_head);
+    
+    /* otherwise we must add our module into the list */
+    swig_module.next = module_head->next;
+    module_head->next = &swig_module;
+  }
+  
+  /* When multiple interpreters are used, a module could have already been initialized in
+       a different interpreter, but not yet have a pointer in this interpreter.
+       In this case, we do not want to continue adding types... everything should be
+       set up already */
+  if (init == 0) return;
+  
+  /* Now work on filling in swig_module.types */
+#ifdef SWIGRUNTIME_DEBUG
+  printf("SWIG_InitializeModule: size %d\n", swig_module.size);
+#endif
+  for (i = 0; i < swig_module.size; ++i) {
+    swig_type_info *type = 0;
+    swig_type_info *ret;
+    swig_cast_info *cast;
+    
+#ifdef SWIGRUNTIME_DEBUG
+    printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
+#endif
+    
+    /* if there is another module already loaded */
+    if (swig_module.next != &swig_module) {
+      type = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, swig_module.type_initial[i]->name);
+    }
+    if (type) {
+      /* Overwrite clientdata field */
+#ifdef SWIGRUNTIME_DEBUG
+      printf("SWIG_InitializeModule: found type %s\n", type->name);
+#endif
+      if (swig_module.type_initial[i]->clientdata) {
+        type->clientdata = swig_module.type_initial[i]->clientdata;
+#ifdef SWIGRUNTIME_DEBUG
+        printf("SWIG_InitializeModule: found and overwrite type %s \n", type->name);
+#endif
+      }
+    } else {
+      type = swig_module.type_initial[i];
+    }
+    
+    /* Insert casting types */
+    cast = swig_module.cast_initial[i];
+    while (cast->type) {
+      /* Don't need to add information already in the list */
+      ret = 0;
+#ifdef SWIGRUNTIME_DEBUG
+      printf("SWIG_InitializeModule: look cast %s\n", cast->type->name);
+#endif
+      if (swig_module.next != &swig_module) {
+        ret = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, cast->type->name);
+#ifdef SWIGRUNTIME_DEBUG
+        if (ret) printf("SWIG_InitializeModule: found cast %s\n", ret->name);
+#endif
+      }
+      if (ret) {
+        if (type == swig_module.type_initial[i]) {
+#ifdef SWIGRUNTIME_DEBUG
+          printf("SWIG_InitializeModule: skip old type %s\n", ret->name);
+#endif
+          cast->type = ret;
+          ret = 0;
+        } else {
+          /* Check for casting already in the list */
+          swig_cast_info *ocast = SWIG_TypeCheck(ret->name, type);
+#ifdef SWIGRUNTIME_DEBUG
+          if (ocast) printf("SWIG_InitializeModule: skip old cast %s\n", ret->name);
+#endif
+          if (!ocast) ret = 0;
+        }
+      }
+      
+      if (!ret) {
+#ifdef SWIGRUNTIME_DEBUG
+        printf("SWIG_InitializeModule: adding cast %s\n", cast->type->name);
+#endif
+        if (type->cast) {
+          type->cast->prev = cast;
+          cast->next = type->cast;
+        }
+        type->cast = cast;
+      }
+      cast++;
+    }
+    /* Set entry in modules->types array equal to the type */
+    swig_module.types[i] = type;
+  }
+  swig_module.types[i] = 0;
+  
+#ifdef SWIGRUNTIME_DEBUG
+  printf("**** SWIG_InitializeModule: Cast List ******\n");
+  for (i = 0; i < swig_module.size; ++i) {
+    int j = 0;
+    swig_cast_info *cast = swig_module.cast_initial[i];
+    printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
+    while (cast->type) {
+      printf("SWIG_InitializeModule: cast type %s\n", cast->type->name);
+      cast++;
+      ++j;
+    }
+    printf("---- Total casts: %d\n",j);
+  }
+  printf("**** SWIG_InitializeModule: Cast List ******\n");
+#endif
+}
+
+/* This function will propagate the clientdata field of type to
+* any new swig_type_info structures that have been added into the list
+* of equivalent types.  It is like calling
+* SWIG_TypeClientData(type, clientdata) a second time.
+*/
+SWIGRUNTIME void
+SWIG_PropagateClientData(void) {
+  size_t i;
+  swig_cast_info *equiv;
+  static int init_run = 0;
+  
+  if (init_run) return;
+  init_run = 1;
+  
+  for (i = 0; i < swig_module.size; i++) {
+    if (swig_module.types[i]->clientdata) {
+      equiv = swig_module.types[i]->cast;
+      while (equiv) {
+        if (!equiv->converter) {
+          if (equiv->type && !equiv->type->clientdata)
+          SWIG_TypeClientData(equiv->type, swig_module.types[i]->clientdata);
+        }
+        equiv = equiv->next;
+      }
+    }
+  }
+}
+
+#ifdef __cplusplus
+#if 0
+{
+  /* c-mode */
+#endif
+}
+#endif
+
+
+
+#if defined(__cplusplus) && ! defined(XSPROTO)
+extern "C"
+#endif
+
+XS(SWIG_init) {
+  dXSARGS;
+  int i;
+  (void)items;
+  
+  SWIG_InitializeModule(0);
+  
+  /* Install commands */
+  for (i = 0; swig_commands[i].name; i++) {
+    /* Casts only needed for Perl < 5.10. */
+#ifdef __cplusplus
+    newXS(const_cast<char*>(swig_commands[i].name), swig_commands[i].wrapper, const_cast<char*>(__FILE__));
+#else
+    newXS((char*)swig_commands[i].name, swig_commands[i].wrapper, (char*)__FILE__);
+#endif
+  }
+  
+  /* Install variables */
+  for (i = 0; swig_variables[i].name; i++) {
+    SV *sv;
+    sv = get_sv(swig_variables[i].name, TRUE | 0x2 | GV_ADDMULTI);
+    if (swig_variables[i].type) {
+      SWIG_MakePtr(sv,(void *)1, *swig_variables[i].type,0);
+    } else {
+      sv_setiv(sv,(IV) 0);
+    }
+    swig_create_magic(sv, swig_variables[i].name, swig_variables[i].set, swig_variables[i].get); 
+  }
+  
+  /* Install constant */
+  for (i = 0; swig_constants[i].type; i++) {
+    SV *sv;
+    sv = get_sv(swig_constants[i].name, TRUE | 0x2 | GV_ADDMULTI);
+    switch(swig_constants[i].type) {
+    case SWIG_INT:
+      sv_setiv(sv, (IV) swig_constants[i].lvalue);
+      break;
+    case SWIG_FLOAT:
+      sv_setnv(sv, (double) swig_constants[i].dvalue);
+      break;
+    case SWIG_STRING:
+      sv_setpv(sv, (const char *) swig_constants[i].pvalue);
+      break;
+    case SWIG_POINTER:
+      SWIG_MakePtr(sv, swig_constants[i].pvalue, *(swig_constants[i].ptype),0);
+      break;
+    case SWIG_BINARY:
+      SWIG_MakePackedObj(sv, swig_constants[i].pvalue, swig_constants[i].lvalue, *(swig_constants[i].ptype));
+      break;
+    default:
+      break;
+    }
+    SvREADONLY_on(sv);
+  }
+  
+  SWIG_TypeClientData(SWIGTYPE_p_std__vectorT_ABAC__Credential_t, (void*) "ABAC::CredentialVector");
+  SWIG_TypeClientData(SWIGTYPE_p__abac_chunk_t, (void*) "ABAC::abac_chunk_t");
+  /*@SWIG:/usr/share/swig3.0/perl5/perltypemaps.swg,65,%set_constant@*/ do {
+    SV *sv = get_sv((char*) SWIG_prefix "ABAC_RC_SUCCESS", TRUE | 0x2 | GV_ADDMULTI);
+    sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1(static_cast< int >(0)));
+    SvREADONLY_on(sv);
+  } while(0) /*@SWIG@*/;
+  /*@SWIG:/usr/share/swig3.0/perl5/perltypemaps.swg,65,%set_constant@*/ do {
+    SV *sv = get_sv((char*) SWIG_prefix "ABAC_RC_FAILURE", TRUE | 0x2 | GV_ADDMULTI);
+    sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1(static_cast< int >(1)));
+    SvREADONLY_on(sv);
+  } while(0) /*@SWIG@*/;
+  /*@SWIG:/usr/share/swig3.0/perl5/perltypemaps.swg,65,%set_constant@*/ do {
+    SV *sv = get_sv((char*) SWIG_prefix "ABAC_CERT_SUCCESS", TRUE | 0x2 | GV_ADDMULTI);
+    sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1(static_cast< int >(0)));
+    SvREADONLY_on(sv);
+  } while(0) /*@SWIG@*/;
+  /*@SWIG:/usr/share/swig3.0/perl5/perltypemaps.swg,65,%set_constant@*/ do {
+    SV *sv = get_sv((char*) SWIG_prefix "ABAC_CERT_INVALID", TRUE | 0x2 | GV_ADDMULTI);
+    sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1(static_cast< int >(-1)));
+    SvREADONLY_on(sv);
+  } while(0) /*@SWIG@*/;
+  /*@SWIG:/usr/share/swig3.0/perl5/perltypemaps.swg,65,%set_constant@*/ do {
+    SV *sv = get_sv((char*) SWIG_prefix "ABAC_CERT_BAD_SIG", TRUE | 0x2 | GV_ADDMULTI);
+    sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1(static_cast< int >(-2)));
+    SvREADONLY_on(sv);
+  } while(0) /*@SWIG@*/;
+  /*@SWIG:/usr/share/swig3.0/perl5/perltypemaps.swg,65,%set_constant@*/ do {
+    SV *sv = get_sv((char*) SWIG_prefix "ABAC_CERT_MISSING_ISSUER", TRUE | 0x2 | GV_ADDMULTI);
+    sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1(static_cast< int >(-3)));
+    SvREADONLY_on(sv);
+  } while(0) /*@SWIG@*/;
+  /*@SWIG:/usr/share/swig3.0/perl5/perltypemaps.swg,65,%set_constant@*/ do {
+    SV *sv = get_sv((char*) SWIG_prefix "ABAC_CERT_BAD_PRINCIPAL", TRUE | 0x2 | GV_ADDMULTI);
+    sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1(static_cast< int >(-4)));
+    SvREADONLY_on(sv);
+  } while(0) /*@SWIG@*/;
+  /*@SWIG:/usr/share/swig3.0/perl5/perltypemaps.swg,65,%set_constant@*/ do {
+    SV *sv = get_sv((char*) SWIG_prefix "ABAC_CERT_INVALID_ISSUER", TRUE | 0x2 | GV_ADDMULTI);
+    sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1(static_cast< int >(-5)));
+    SvREADONLY_on(sv);
+  } while(0) /*@SWIG@*/;
+  /*@SWIG:/usr/share/swig3.0/perl5/perltypemaps.swg,65,%set_constant@*/ do {
+    SV *sv = get_sv((char*) SWIG_prefix "ABAC_CERT_SIGNER_NOKEY", TRUE | 0x2 | GV_ADDMULTI);
+    sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1(static_cast< int >(-6)));
+    SvREADONLY_on(sv);
+  } while(0) /*@SWIG@*/;
+  /*@SWIG:/usr/share/swig3.0/perl5/perltypemaps.swg,65,%set_constant@*/ do {
+    SV *sv = get_sv((char*) SWIG_prefix "ABAC_SUCCESS", TRUE | 0x2 | GV_ADDMULTI);
+    sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1(static_cast< int >(0)));
+    SvREADONLY_on(sv);
+  } while(0) /*@SWIG@*/;
+  /*@SWIG:/usr/share/swig3.0/perl5/perltypemaps.swg,65,%set_constant@*/ do {
+    SV *sv = get_sv((char*) SWIG_prefix "ABAC_FAILURE", TRUE | 0x2 | GV_ADDMULTI);
+    sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1(static_cast< int >(1)));
+    SvREADONLY_on(sv);
+  } while(0) /*@SWIG@*/;
+  /*@SWIG:/usr/share/swig3.0/perl5/perltypemaps.swg,65,%set_constant@*/ do {
+    SV *sv = get_sv((char*) SWIG_prefix "ABAC_GENERATE_INVALID_CN", TRUE | 0x2 | GV_ADDMULTI);
+    sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1(static_cast< int >(-1)));
+    SvREADONLY_on(sv);
+  } while(0) /*@SWIG@*/;
+  /*@SWIG:/usr/share/swig3.0/perl5/perltypemaps.swg,65,%set_constant@*/ do {
+    SV *sv = get_sv((char*) SWIG_prefix "ABAC_GENERATE_INVALID_VALIDITY", TRUE | 0x2 | GV_ADDMULTI);
+    sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1(static_cast< int >(-2)));
+    SvREADONLY_on(sv);
+  } while(0) /*@SWIG@*/;
+  /*@SWIG:/usr/share/swig3.0/perl5/perltypemaps.swg,65,%set_constant@*/ do {
+    SV *sv = get_sv((char*) SWIG_prefix "ABAC_ATTRIBUTE_ISSUER_NOKEY", TRUE | 0x2 | GV_ADDMULTI);
+    sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1(static_cast< int >(-3)));
+    SvREADONLY_on(sv);
+  } while(0) /*@SWIG@*/;
+  /*@SWIG:/usr/share/swig3.0/perl5/perltypemaps.swg,65,%set_constant@*/ do {
+    SV *sv = get_sv((char*) SWIG_prefix "ABAC_ATTRIBUTE_INVALID_ROLE", TRUE | 0x2 | GV_ADDMULTI);
+    sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1(static_cast< int >(-4)));
+    SvREADONLY_on(sv);
+  } while(0) /*@SWIG@*/;
+  /*@SWIG:/usr/share/swig3.0/perl5/perltypemaps.swg,65,%set_constant@*/ do {
+    SV *sv = get_sv((char*) SWIG_prefix "ABAC_ATTRIBUTE_INVALID_VALIDITY", TRUE | 0x2 | GV_ADDMULTI);
+    sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1(static_cast< int >(-5)));
+    SvREADONLY_on(sv);
+  } while(0) /*@SWIG@*/;
+  /*@SWIG:/usr/share/swig3.0/perl5/perltypemaps.swg,65,%set_constant@*/ do {
+    SV *sv = get_sv((char*) SWIG_prefix "ABAC_ATTRIBUTE_INVALID_ISSUER", TRUE | 0x2 | GV_ADDMULTI);
+    sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1(static_cast< int >(-6)));
+    SvREADONLY_on(sv);
+  } while(0) /*@SWIG@*/;
+  SWIG_TypeClientData(SWIGTYPE_p_ABAC__Context, (void*) "ABAC::Context");
+  SWIG_TypeClientData(SWIGTYPE_p_ABAC__Role, (void*) "ABAC::Role");
+  SWIG_TypeClientData(SWIGTYPE_p_ABAC__Credential, (void*) "ABAC::Credential");
+  SWIG_TypeClientData(SWIGTYPE_p_ABAC__ID, (void*) "ABAC::ID");
+  SWIG_TypeClientData(SWIGTYPE_p_ABAC__Attribute, (void*) "ABAC::Attribute");
+  ST(0) = &PL_sv_yes;
+  XSRETURN(1);
+}
+
