PR88788 - Infinite loop in malloc_candidate_p_1

Message ID CAAgBjMkCNw24QrLhF9AMMfSggNQJwjXnF3Q8uYV5Q17fVXZJWA@mail.gmail.com
State New
Headers show
Series
  • PR88788 - Infinite loop in malloc_candidate_p_1
Related show

Commit Message

Prathamesh Kulkarni Jan. 15, 2019, 6:59 a.m.
Hi Richard,
I tested your fix and it passes bootstrap+test on
x86_64-unknown-linux-gnu and cross-tested on following arm and aarch64
sub-targets:
http://people.linaro.org/~christophe.lyon/cross-validation/gcc-test-patches/267917-pr88788-3/report-build-info.html

Is it OK to commit ?

Thanks,
Prathamesh
2019-01-15  Richard Biener  <rguenther@suse.de>
	    Prathamesh Kulkarni  <prathamesh.kulkarni@linaro.org>

	PR ipa/88378
	* ipa-pure-const.c (malloc_candidate_p_1): Add parameter visited and
	return true if SSA_NAME is already marked in visited bitmap.
	* (malloc_candidate_p): Pass visited to malloc_candidate_p_1.

testsuite/
	* g++.dg/ipa/pr88788.C: New test.

Comments

Richard Biener Jan. 15, 2019, 8:36 a.m. | #1
On Tue, 15 Jan 2019, Prathamesh Kulkarni wrote:

> Hi Richard,

> I tested your fix and it passes bootstrap+test on

> x86_64-unknown-linux-gnu and cross-tested on following arm and aarch64

> sub-targets:

> http://people.linaro.org/~christophe.lyon/cross-validation/gcc-test-patches/267917-pr88788-3/report-build-info.html

> 

> Is it OK to commit ?


OK

Thanks,
Richard.

> Thanks,

> Prathamesh

> 


-- 
Richard Biener <rguenther@suse.de>
SUSE LINUX GmbH, GF: Felix Imendoerffer, Jane Smithard, Graham Norton, HRB 21284 (AG Nuernberg)
Jakub Jelinek Jan. 15, 2019, 8:41 a.m. | #2
On Tue, Jan 15, 2019 at 12:29:21PM +0530, Prathamesh Kulkarni wrote:
> 2019-01-15  Richard Biener  <rguenther@suse.de>

> 	    Prathamesh Kulkarni  <prathamesh.kulkarni@linaro.org>

> 

> 	PR ipa/88378


Wrong PR number.

> 	* ipa-pure-const.c (malloc_candidate_p_1): Add parameter visited and

> 	return true if SSA_NAME is already marked in visited bitmap.

> 	* (malloc_candidate_p): Pass visited to malloc_candidate_p_1.

> 

> testsuite/

> 	* g++.dg/ipa/pr88788.C: New test.


The testcase looks way too large to me, can't we reduce it?

delta/creduce with a hanging compiler isn't fast (one would need to use
timeout), but e.g. in #c1 you have a patch to get an ICE instead of hang if
it happens.

	Jakub
Richard Biener Jan. 15, 2019, 9:03 a.m. | #3
On Tue, 15 Jan 2019, Jakub Jelinek wrote:

> On Tue, Jan 15, 2019 at 12:29:21PM +0530, Prathamesh Kulkarni wrote:

> > 2019-01-15  Richard Biener  <rguenther@suse.de>

> > 	    Prathamesh Kulkarni  <prathamesh.kulkarni@linaro.org>

> > 

> > 	PR ipa/88378

> 

> Wrong PR number.

> 

> > 	* ipa-pure-const.c (malloc_candidate_p_1): Add parameter visited and

> > 	return true if SSA_NAME is already marked in visited bitmap.

> > 	* (malloc_candidate_p): Pass visited to malloc_candidate_p_1.

> > 

> > testsuite/

> > 	* g++.dg/ipa/pr88788.C: New test.

> 

> The testcase looks way too large to me, can't we reduce it?

> 

> delta/creduce with a hanging compiler isn't fast (one would need to use

> timeout), but e.g. in #c1 you have a patch to get an ICE instead of hang if

> it happens.


Or just omit the testcase - even with the bitmap we can end up recursing
very many times thus the ICE can happen spuriously.

Richard.
Prathamesh Kulkarni Jan. 15, 2019, 9:39 a.m. | #4
On Tue, 15 Jan 2019 at 14:33, Richard Biener <rguenther@suse.de> wrote:
>

> On Tue, 15 Jan 2019, Jakub Jelinek wrote:

>

> > On Tue, Jan 15, 2019 at 12:29:21PM +0530, Prathamesh Kulkarni wrote:

> > > 2019-01-15  Richard Biener  <rguenther@suse.de>

> > >         Prathamesh Kulkarni  <prathamesh.kulkarni@linaro.org>

> > >

> > >     PR ipa/88378

> >

> > Wrong PR number.

> >

> > >     * ipa-pure-const.c (malloc_candidate_p_1): Add parameter visited and

> > >     return true if SSA_NAME is already marked in visited bitmap.

> > >     * (malloc_candidate_p): Pass visited to malloc_candidate_p_1.

> > >

> > > testsuite/

> > >     * g++.dg/ipa/pr88788.C: New test.

> >

> > The testcase looks way too large to me, can't we reduce it?

> >

> > delta/creduce with a hanging compiler isn't fast (one would need to use

> > timeout), but e.g. in #c1 you have a patch to get an ICE instead of hang if

> > it happens.

>

> Or just omit the testcase - even with the bitmap we can end up recursing

> very many times thus the ICE can happen spuriously.

I committed patch in r267933 omitting the test-case.
Thanks Richard and Jakub for help with the bug!

Thanks,
Prathamesh
>

> Richard.

Patch

diff --git a/gcc/ipa-pure-const.c b/gcc/ipa-pure-const.c
index 37b58853fe1..8227eed29bc 100644
--- a/gcc/ipa-pure-const.c
+++ b/gcc/ipa-pure-const.c
@@ -878,9 +878,12 @@  check_retval_uses (tree retval, gimple *stmt)
 }
 
 static bool
-malloc_candidate_p_1 (function *fun, tree retval, gimple *ret_stmt, bool ipa)
+malloc_candidate_p_1 (function *fun, tree retval, gimple *ret_stmt, bool ipa,
+		      bitmap visited)
 {
   cgraph_node *node = cgraph_node::get_create (fun->decl);
+  if (!bitmap_set_bit (visited, SSA_NAME_VERSION (retval)))
+    return true;
 
   if (!check_retval_uses (retval, ret_stmt))
     DUMP_AND_RETURN("Return value has uses outside return stmt"
@@ -925,7 +928,7 @@  malloc_candidate_p_1 (function *fun, tree retval, gimple *ret_stmt, bool ipa)
 	    gimple *arg_def = SSA_NAME_DEF_STMT (arg);
 	    if (is_a<gphi *> (arg_def))
 	      {
-		if (!malloc_candidate_p_1 (fun, arg, phi, ipa))
+		if (!malloc_candidate_p_1 (fun, arg, phi, ipa, visited))
 		    DUMP_AND_RETURN ("nested phi fail")
 		continue;
 	      }
@@ -971,6 +974,7 @@  malloc_candidate_p (function *fun, bool ipa)
       || !flag_delete_null_pointer_checks)
     return false;
 
+  auto_bitmap visited;
   FOR_EACH_EDGE (e, ei, exit_block->preds)
     {
       gimple_stmt_iterator gsi = gsi_last_bb (e->src);
@@ -987,7 +991,7 @@  malloc_candidate_p (function *fun, bool ipa)
 	  || TREE_CODE (TREE_TYPE (retval)) != POINTER_TYPE)
 	DUMP_AND_RETURN("Return value is not SSA_NAME or not a pointer type.")
 
-      if (!malloc_candidate_p_1 (fun, retval, ret_stmt, ipa))
+      if (!malloc_candidate_p_1 (fun, retval, ret_stmt, ipa, visited))
 	return false;
     }
 
diff --git a/gcc/testsuite/g++.dg/ipa/pr88788.C b/gcc/testsuite/g++.dg/ipa/pr88788.C
new file mode 100644
index 00000000000..94af174f82c
--- /dev/null
+++ b/gcc/testsuite/g++.dg/ipa/pr88788.C
@@ -0,0 +1,1003 @@ 
+/* { dg-do compile } */
+/* { dg-options "-w -O2" } */
+
+  extern "C" {
+              typedef long unsigned int size_t;
+              typedef long int __ssize_t;
+              typedef __ssize_t ssize_t;
+              extern int strncmp (const char *__s1, const char *__s2, size_t __n)      throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));
+              extern size_t strlen (const char *__s)      throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));
+              extern void *malloc (size_t __size) throw () __attribute__ ((__malloc__)) __attribute__ ((__warn_unused_result__));
+              }
+                   typedef ssize_t Py_ssize_t;
+                     extern "C" {
+              typedef struct _object 
+              PyObject;
+              typedef struct 
+              _Py_Identifier;
+              typedef PyObject *(*PyCFunction)(PyObject *, PyObject *);
+              struct PyMethodDef {
+              const char *ml_name;
+              PyCFunction ml_meth;
+              int ml_flags;
+              const char *ml_doc;
+          };
+              typedef struct swig_type_info *(*swig_dycast_func)(void **);
+              typedef struct swig_type_info {
+            const char *name;
+            const char *str;
+            swig_dycast_func dcast;
+            struct swig_cast_info *cast;
+            void *clientdata;
+            int owndata;
+          }
+              swig_type_info;
+              static __attribute__ ((__unused__)) char * SWIG_PackVoidPtr(char *buff, void *ptr, const char *name, size_t bsz) ;
+              typedef struct swig_const_info {
+            int type;
+            char *name;
+            void *pvalue;
+            swig_type_info **ptype;
+          }
+              swig_const_info;
+              static __attribute__ ((__unused__)) PyObject * SWIG_Python_NewPointerObj(PyObject *self, void *ptr, swig_type_info *type, int flags) ;
+                    }
+                   static swig_type_info *swig_types[276];
+                   namespace boost {
+              namespace noncopyable_ {
+            class noncopyable   {
+         protected:                               };
+          }
+              typedef noncopyable_::noncopyable noncopyable;
+              }
+                   namespace storage {
+                  class Device : private boost::noncopyable     {
+           virtual Device* clone() const = 0;
+              };
+                       class Mountable : public Device     {
+                  protected:       };
+                  class Filesystem : public Mountable     {
+                  protected:       };
+                  class BlkFilesystem : public Filesystem     {
+                  protected:       };
+                  class Ext : public BlkFilesystem     {
+                  protected:       };
+                  class Ext2 : public Ext     {
+                    protected:       };
+                  class Ext3 : public Ext     {
+                    protected:       };
+                  class Ext4 : public Ext     {
+                    protected:       };
+                  class Ntfs : public BlkFilesystem     {
+                    protected:       };
+                  class Vfat : public BlkFilesystem     {
+                    protected:       };
+                  class Exfat : public BlkFilesystem     {
+                    protected:       };
+                  class Btrfs : public BlkFilesystem     {
+                    protected:       };
+                  class BtrfsSubvolume : public Mountable     {
+                    protected:       };
+                  class Reiserfs : public BlkFilesystem     {
+                    protected:       };
+                  class Xfs : public BlkFilesystem     {
+                    protected:       };
+                  class Jfs : public BlkFilesystem     {
+                    protected:       };
+                  class F2fs : public BlkFilesystem     {
+                    protected:       };
+                  class Swap : public BlkFilesystem     {
+                    protected:       };
+                  class Iso9660 : public BlkFilesystem     {
+                    protected:       };
+                  class Udf : public BlkFilesystem     {
+                    protected:       };
+                  class Nfs : public Filesystem     {
+                    protected:       };
+                  class MountPoint : public Device     {
+                    protected:       };
+                  class BlkDevice : public Device     {
+                  protected:       };
+                  class Partition : public BlkDevice     {
+                  };
+                  class PartitionTable : public Device     {
+                  protected:       };
+                  class Partitionable : public BlkDevice     {
+                  protected:       };
+                  class StrayBlkDevice : public BlkDevice     {
+                    protected:       };
+                       class Disk : public Partitionable     {
+                    protected:       };
+                  class Dasd : public Partitionable     {
+                    protected:       };
+                  class Multipath : public Partitionable     {
+                    protected:       };
+                  class DmRaid : public Partitionable     {
+                    protected:       };
+                            class Md : public Partitionable     {
+                    protected:       };
+                  class MdContainer : public Md     {
+                    protected:       };
+                  class MdMember : public Md     {
+                    protected:       };
+                  class Gpt : public PartitionTable     {
+                    protected:       };
+                  class DasdPt : public PartitionTable     {
+                    protected:       };
+                  class LvmPv : public Device     {
+                    protected:       };
+                  class LvmLv : public BlkDevice     {
+                    protected:       };
+                  class LvmVg : public Device     {
+                    protected:       };
+                  class Encryption : public BlkDevice     {
+                    protected:       };
+                  class Luks : public Encryption     {
+                    protected:       };
+                  class Bcache : public Partitionable     {
+                    protected:       };
+                  class BcacheCset : public Device     {
+                    protected:       };
+                     const storage::Device*  downcast(const storage::Device* device)  ;
+              }
+                                                                               extern "C" {
+              static __attribute__ ((__unused__)) PyObject *_wrap_downcast__SWIG_1(PyObject *, PyObject *args) {
+            PyObject *resultobj = 0;
+            storage::Device *arg1 = (storage::Device *) 0 ;
+            storage::Device *result = 0 ;
+            result = (storage::Device *)storage::downcast((storage::Device const *)arg1);
+            {
+           int dcast = 0;
+           if (!dcast) {
+          const storage::BcacheCset *dobj = dynamic_cast<const storage::BcacheCset *>(result);
+          if (dobj) {
+           dcast = 1;
+         }
+        }
+           if (!dcast) {
+          const storage::Luks *dobj = dynamic_cast<const storage::Luks *>(result);
+          if (dobj) {
+           resultobj = SWIG_Python_NewPointerObj(                    __null                    , const_cast< void * >(static_cast< const void * >(dobj)), swig_types[217], 0 | 0);
+         }
+          if (dobj) {
+           dcast = 1;
+           resultobj = SWIG_Python_NewPointerObj(                    __null                    , const_cast< void * >(static_cast< const void * >(dobj)), swig_types[189], 0 | 0);
+         }
+        }
+           if (!dcast) {
+          const storage::LvmLv *dobj = dynamic_cast<const storage::LvmLv *>(result);
+          if (dobj) {
+           dcast = 1;
+           resultobj = SWIG_Python_NewPointerObj(                    __null                    , const_cast< void * >(static_cast< const void * >(dobj)), swig_types[218], 0 | 0);
+         }
+        }
+           if (!dcast) {
+          const storage::Partition *dobj = dynamic_cast<const storage::Partition *>(result);
+          if (dobj) {
+           dcast = 1;
+           resultobj = SWIG_Python_NewPointerObj(                    __null                    , const_cast< void * >(static_cast< const void * >(dobj)), swig_types[241], 0 | 0);
+         }
+        }
+           if (!dcast) {
+          const storage::Bcache *dobj = dynamic_cast<const storage::Bcache *>(result);
+          if (dobj) {
+           dcast = 1;
+           resultobj = SWIG_Python_NewPointerObj(                    __null                    , const_cast< void * >(static_cast< const void * >(dobj)), swig_types[162], 0 | 0);
+         }
+        }
+           if (!dcast) {
+          const storage::Dasd *dobj = dynamic_cast<const storage::Dasd *>(result);
+          if (dobj) {
+           dcast = 1;
+           resultobj = SWIG_Python_NewPointerObj(                    __null                    , const_cast< void * >(static_cast< const void * >(dobj)), swig_types[176], 0 | 0);
+         }
+        }
+           if (!dcast) {
+          const storage::Disk *dobj = dynamic_cast<const storage::Disk *>(result);
+          if (dobj) {
+           dcast = 1;
+           resultobj = SWIG_Python_NewPointerObj(                    __null                    , const_cast< void * >(static_cast< const void * >(dobj)), swig_types[187], 0 | 0);
+         }
+        }
+           if (!dcast) {
+          const storage::DmRaid *dobj = dynamic_cast<const storage::DmRaid *>(result);
+          if (dobj) {
+           dcast = 1;
+           resultobj = SWIG_Python_NewPointerObj(                    __null                    , const_cast< void * >(static_cast< const void * >(dobj)), swig_types[188], 0 | 0);
+         }
+        }
+           if (!dcast) {
+          const storage::MdContainer *dobj = dynamic_cast<const storage::MdContainer *>(result);
+          if (dobj) {
+           dcast = 1;
+           resultobj = SWIG_Python_NewPointerObj(                    __null                    , const_cast< void * >(static_cast< const void * >(dobj)), swig_types[224], 0 | 0);
+         }
+        }
+           if (!dcast) {
+          const storage::MdMember *dobj = dynamic_cast<const storage::MdMember *>(result);
+          if (dobj) {
+           dcast = 1;
+           resultobj = SWIG_Python_NewPointerObj(                    __null                    , const_cast< void * >(static_cast< const void * >(dobj)), swig_types[225], 0 | 0);
+         }
+        }
+           if (!dcast) {
+          const storage::Md *dobj = dynamic_cast<const storage::Md *>(result);
+          if (dobj) {
+           dcast = 1;
+           resultobj = SWIG_Python_NewPointerObj(                    __null                    , const_cast< void * >(static_cast< const void * >(dobj)), swig_types[223], 0 | 0);
+         }
+        }
+           if (!dcast) {
+          const storage::Multipath *dobj = dynamic_cast<const storage::Multipath *>(result);
+          if (dobj) {
+           dcast = 1;
+           resultobj = SWIG_Python_NewPointerObj(                    __null                    , const_cast< void * >(static_cast< const void * >(dobj)), swig_types[231], 0 | 0);
+         }
+        }
+           if (!dcast) {
+          const storage::Partitionable *dobj = dynamic_cast<const storage::Partitionable *>(result);
+          if (dobj) {
+           dcast = 1;
+           resultobj = SWIG_Python_NewPointerObj(                    __null                    , const_cast< void * >(static_cast< const void * >(dobj)), swig_types[244], 0 | 0);
+         }
+        }
+           if (!dcast) {
+          const storage::StrayBlkDevice *dobj = dynamic_cast<const storage::StrayBlkDevice *>(result);
+          if (dobj) {
+           dcast = 1;
+           resultobj = SWIG_Python_NewPointerObj(                    __null                    , const_cast< void * >(static_cast< const void * >(dobj)), swig_types[257], 0 | 0);
+         }
+        }
+           if (!dcast) {
+          const storage::BlkDevice *dobj = dynamic_cast<const storage::BlkDevice *>(result);
+          if (dobj) {
+           dcast = 1;
+           resultobj = SWIG_Python_NewPointerObj(                    __null                    , const_cast< void * >(static_cast< const void * >(dobj)), swig_types[164], 0 | 0);
+         }
+        }
+           if (!dcast) {
+          const storage::LvmPv *dobj = dynamic_cast<const storage::LvmPv *>(result);
+          if (dobj) {
+           dcast = 1;
+           resultobj = SWIG_Python_NewPointerObj(                    __null                    , const_cast< void * >(static_cast< const void * >(dobj)), swig_types[220], 0 | 0);
+         }
+        }
+           if (!dcast) {
+          const storage::LvmVg *dobj = dynamic_cast<const storage::LvmVg *>(result);
+          if (dobj) {
+           dcast = 1;
+           resultobj = SWIG_Python_NewPointerObj(                    __null                    , const_cast< void * >(static_cast< const void * >(dobj)), swig_types[221], 0 | 0);
+         }
+        }
+           if (!dcast) {
+          const storage::MountPoint *dobj = dynamic_cast<const storage::MountPoint *>(result);
+          if (dobj) {
+           dcast = 1;
+           resultobj = SWIG_Python_NewPointerObj(                    __null                    , const_cast< void * >(static_cast< const void * >(dobj)), swig_types[228], 0 | 0);
+         }
+        }
+           if (!dcast) {
+          const storage::BtrfsSubvolume *dobj = dynamic_cast<const storage::BtrfsSubvolume *>(result);
+          if (dobj) {
+           dcast = 1;
+           resultobj = SWIG_Python_NewPointerObj(                    __null                    , const_cast< void * >(static_cast< const void * >(dobj)), swig_types[167], 0 | 0);
+         }
+        }
+           if (!dcast) {
+          const storage::Btrfs *dobj = dynamic_cast<const storage::Btrfs *>(result);
+          if (dobj) {
+           dcast = 1;
+           resultobj = SWIG_Python_NewPointerObj(                    __null                    , const_cast< void * >(static_cast< const void * >(dobj)), swig_types[166], 0 | 0);
+         }
+        }
+           if (!dcast) {
+          const storage::Exfat *dobj = dynamic_cast<const storage::Exfat *>(result);
+          if (dobj) {
+           dcast = 1;
+           resultobj = SWIG_Python_NewPointerObj(                    __null                    , const_cast< void * >(static_cast< const void * >(dobj)), swig_types[192], 0 | 0);
+         }
+        }
+           if (!dcast) {
+          const storage::Ext2 *dobj = dynamic_cast<const storage::Ext2 *>(result);
+          if (dobj) {
+           dcast = 1;
+           resultobj = SWIG_Python_NewPointerObj(                    __null                    , const_cast< void * >(static_cast< const void * >(dobj)), swig_types[194], 0 | 0);
+         }
+        }
+           if (!dcast) {
+          const storage::Ext3 *dobj = dynamic_cast<const storage::Ext3 *>(result);
+          if (dobj) {
+           dcast = 1;
+           resultobj = SWIG_Python_NewPointerObj(                    __null                    , const_cast< void * >(static_cast< const void * >(dobj)), swig_types[195], 0 | 0);
+         }
+        }
+           if (!dcast) {
+          const storage::Ext4 *dobj = dynamic_cast<const storage::Ext4 *>(result);
+          if (dobj) {
+           dcast = 1;
+           resultobj = SWIG_Python_NewPointerObj(                    __null                    , const_cast< void * >(static_cast< const void * >(dobj)), swig_types[196], 0 | 0);
+         }
+        }
+           if (!dcast) {
+          const storage::Ext *dobj = dynamic_cast<const storage::Ext *>(result);
+          if (dobj) {
+           dcast = 1;
+           resultobj = SWIG_Python_NewPointerObj(                    __null                    , const_cast< void * >(static_cast< const void * >(dobj)), swig_types[193], 0 | 0);
+         }
+        }
+           if (!dcast) {
+          const storage::F2fs *dobj = dynamic_cast<const storage::F2fs *>(result);
+          if (dobj) {
+           dcast = 1;
+           resultobj = SWIG_Python_NewPointerObj(                    __null                    , const_cast< void * >(static_cast< const void * >(dobj)), swig_types[197], 0 | 0);
+         }
+        }
+           if (!dcast) {
+          const storage::Iso9660 *dobj = dynamic_cast<const storage::Iso9660 *>(result);
+          if (dobj) {
+           dcast = 1;
+           resultobj = SWIG_Python_NewPointerObj(                    __null                    , const_cast< void * >(static_cast< const void * >(dobj)), swig_types[212], 0 | 0);
+         }
+        }
+           if (!dcast) {
+          const storage::Jfs *dobj = dynamic_cast<const storage::Jfs *>(result);
+          if (dobj) {
+           dcast = 1;
+           resultobj = SWIG_Python_NewPointerObj(                    __null                    , const_cast< void * >(static_cast< const void * >(dobj)), swig_types[213], 0 | 0);
+         }
+        }
+           if (!dcast) {
+          const storage::Ntfs *dobj = dynamic_cast<const storage::Ntfs *>(result);
+          if (dobj) {
+           dcast = 1;
+           resultobj = SWIG_Python_NewPointerObj(                    __null                    , const_cast< void * >(static_cast< const void * >(dobj)), swig_types[236], 0 | 0);
+         }
+        }
+           if (!dcast) {
+          const storage::Reiserfs *dobj = dynamic_cast<const storage::Reiserfs *>(result);
+          if (dobj) {
+           dcast = 1;
+           resultobj = SWIG_Python_NewPointerObj(                    __null                    , const_cast< void * >(static_cast< const void * >(dobj)), swig_types[247], 0 | 0);
+         }
+        }
+           if (!dcast) {
+          const storage::Swap *dobj = dynamic_cast<const storage::Swap *>(result);
+          if (dobj) {
+           dcast = 1;
+           resultobj = SWIG_Python_NewPointerObj(                    __null                    , const_cast< void * >(static_cast< const void * >(dobj)), swig_types[259], 0 | 0);
+         }
+        }
+           if (!dcast) {
+          const storage::Udf *dobj = dynamic_cast<const storage::Udf *>(result);
+          if (dobj) {
+           dcast = 1;
+           resultobj = SWIG_Python_NewPointerObj(                    __null                    , const_cast< void * >(static_cast< const void * >(dobj)), swig_types[261], 0 | 0);
+         }
+        }
+           if (!dcast) {
+          const storage::Vfat *dobj = dynamic_cast<const storage::Vfat *>(result);
+          if (dobj) {
+           dcast = 1;
+           resultobj = SWIG_Python_NewPointerObj(                    __null                    , const_cast< void * >(static_cast< const void * >(dobj)), swig_types[264], 0 | 0);
+         }
+        }
+           if (!dcast) {
+          const storage::Xfs *dobj = dynamic_cast<const storage::Xfs *>(result);
+          if (dobj) {
+           dcast = 1;
+           resultobj = SWIG_Python_NewPointerObj(                    __null                    , const_cast< void * >(static_cast< const void * >(dobj)), swig_types[267], 0 | 0);
+         }
+        }
+           if (!dcast) {
+          const storage::BlkFilesystem *dobj = dynamic_cast<const storage::BlkFilesystem *>(result);
+          if (dobj) {
+           dcast = 1;
+           resultobj = SWIG_Python_NewPointerObj(                    __null                    , const_cast< void * >(static_cast< const void * >(dobj)), swig_types[165], 0 | 0);
+         }
+        }
+           if (!dcast) {
+          const storage::Nfs *dobj = dynamic_cast<const storage::Nfs *>(result);
+          if (dobj) {
+           dcast = 1;
+           resultobj = SWIG_Python_NewPointerObj(                    __null                    , const_cast< void * >(static_cast< const void * >(dobj)), swig_types[232], 0 | 0);
+         }
+        }
+           if (!dcast) {
+          const storage::Filesystem *dobj = dynamic_cast<const storage::Filesystem *>(result);
+          if (dobj) {
+           dcast = 1;
+           resultobj = SWIG_Python_NewPointerObj(                    __null                    , const_cast< void * >(static_cast< const void * >(dobj)), swig_types[198], 0 | 0);
+         }
+        }
+           if (!dcast) {
+          const storage::Mountable *dobj = dynamic_cast<const storage::Mountable *>(result);
+          if (dobj) {
+           dcast = 1;
+           resultobj = SWIG_Python_NewPointerObj(                    __null                    , const_cast< void * >(static_cast< const void * >(dobj)), swig_types[229], 0 | 0);
+         }
+        }
+           if (!dcast) {
+          const storage::DasdPt *dobj = dynamic_cast<const storage::DasdPt *>(result);
+          if (dobj) {
+           dcast = 1;
+           resultobj = SWIG_Python_NewPointerObj(                    __null                    , const_cast< void * >(static_cast< const void * >(dobj)), swig_types[177], 0 | 0);
+         }
+        }
+           if (!dcast) {
+          const storage::Gpt *dobj = dynamic_cast<const storage::Gpt *>(result);
+        }
+           if (!dcast) {
+          resultobj = SWIG_Python_NewPointerObj(                  __null                  , const_cast< void * >(static_cast< const void * >(result)), swig_types[179], 0 | 0);
+        }
+         }
+            return resultobj;
+          }
+              static __attribute__ ((__unused__)) PyObject *_wrap_downcast(PyObject *self, PyObject *args) {
+            Py_ssize_t argc;
+            if (argc == 1) {
+           int _v;
+           if (_v) {
+          return _wrap_downcast__SWIG_1(self, args);
+        }
+         }
+          }
+              static PyMethodDef SwigMethods[] = {
+            {
+       (char *)"downcast", _wrap_downcast, 0x0001,                                                       __null                                                          }
+          };
+              static swig_type_info _swigt__p_allocator_type ;
+              static swig_type_info _swigt__p_char ;
+              static swig_type_info _swigt__p_const_reference ;
+              static swig_type_info _swigt__p_difference_type = {
+         "_p_difference_type", "difference_type *", 0, 0, (void*)0, 0};
+              static swig_type_info _swigt__p_first_type = {
+         "_p_first_type", "first_type *", 0, 0, (void*)0, 0};
+              static swig_type_info _swigt__p_int = {
+         "_p_int", "intptr_t *|int *|int_least32_t *|int_fast32_t *|int32_t *|int_fast16_t *|pid_t *", 0, 0, (void*)0, 0};
+              static swig_type_info _swigt__p_key_type = {
+         "_p_key_type", "key_type *", 0, 0, (void*)0, 0};
+              static swig_type_info _swigt__p_long_long = {
+         "_p_long_long", "int_least64_t *|int_fast64_t *|int64_t *|long long *|intmax_t *", 0, 0, (void*)0, 0};
+              static swig_type_info _swigt__p_mapped_type = {
+         "_p_mapped_type", "mapped_type *", 0, 0, (void*)0, 0};
+              static swig_type_info _swigt__p_p_PyObject = {
+         "_p_p_PyObject", "PyObject **", 0, 0, (void*)0, 0};
+              static swig_type_info _swigt__p_reference = {
+         "_p_reference", "reference *", 0, 0, (void*)0, 0};
+              static swig_type_info _swigt__p_second_type = {
+         "_p_second_type", "second_type *", 0, 0, (void*)0, 0};
+              static swig_type_info _swigt__p_short = {
+         "_p_short", "short *|int_least16_t *|int16_t *", 0, 0, (void*)0, 0};
+              static swig_type_info _swigt__p_signed_char = {
+         "_p_signed_char", "signed char *|int_least8_t *|int_fast8_t *|int8_t *", 0, 0, (void*)0, 0};
+              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__allocatorT_std__pairT_std__string_const_std__string_t_t = {
+         "_p_std__allocatorT_std__pairT_std__string_const_std__string_t_t", "std::map< std::string,std::string >::allocator_type *|std::allocator< std::pair< std::string const,std::string > > *", 0, 0, (void*)0, 0};
+              static swig_type_info _swigt__p_std__allocatorT_std__string_t = {
+         "_p_std__allocatorT_std__string_t", "std::vector< std::string >::allocator_type *|std::allocator< std::string > *", 0, 0, (void*)0, 0};
+              static swig_type_info _swigt__p_std__allocatorT_storage__BcacheCset_const_p_t = {
+         "_p_std__allocatorT_storage__BcacheCset_const_p_t", "std::allocator< storage::BcacheCset const * > *|std::vector< storage::BcacheCset const * >::allocator_type *", 0, 0, (void*)0, 0};
+              static swig_type_info _swigt__p_std__allocatorT_storage__BcacheCset_p_t = {
+         "_p_std__allocatorT_storage__BcacheCset_p_t", "std::vector< storage::BcacheCset * >::allocator_type *|std::allocator< storage::BcacheCset * > *", 0, 0, (void*)0, 0};
+              static swig_type_info _swigt__p_std__allocatorT_storage__Bcache_const_p_t = {
+         "_p_std__allocatorT_storage__Bcache_const_p_t", "std::vector< storage::Bcache const * >::allocator_type *|std::allocator< storage::Bcache const * > *", 0, 0, (void*)0, 0};
+              static swig_type_info _swigt__p_std__allocatorT_storage__Bcache_p_t = {
+         "_p_std__allocatorT_storage__Bcache_p_t", "std::vector< storage::Bcache * >::allocator_type *|std::allocator< storage::Bcache * > *", 0, 0, (void*)0, 0};
+              static swig_type_info _swigt__p_std__allocatorT_storage__BlkDevice_const_p_t = {
+         "_p_std__allocatorT_storage__BlkDevice_const_p_t", "std::vector< storage::BlkDevice const * >::allocator_type *|std::allocator< storage::BlkDevice const * > *", 0, 0, (void*)0, 0};
+              static swig_type_info _swigt__p_std__allocatorT_storage__BlkDevice_p_t = {
+         "_p_std__allocatorT_storage__BlkDevice_p_t", "std::vector< storage::BlkDevice * >::allocator_type *|std::allocator< storage::BlkDevice * > *", 0, 0, (void*)0, 0};
+              static swig_type_info _swigt__p_std__allocatorT_storage__BlkFilesystem_const_p_t = {
+         "_p_std__allocatorT_storage__BlkFilesystem_const_p_t", "std::vector< storage::BlkFilesystem const * >::allocator_type *|std::allocator< storage::BlkFilesystem const * > *", 0, 0, (void*)0, 0};
+              static swig_type_info _swigt__p_std__allocatorT_storage__BlkFilesystem_p_t = {
+         "_p_std__allocatorT_storage__BlkFilesystem_p_t", "std::allocator< storage::BlkFilesystem * > *|std::vector< storage::BlkFilesystem * >::allocator_type *", 0, 0, (void*)0, 0};
+              static swig_type_info _swigt__p_std__allocatorT_storage__BtrfsSubvolume_const_p_t = {
+         "_p_std__allocatorT_storage__BtrfsSubvolume_const_p_t", "std::allocator< storage::BtrfsSubvolume const * > *|std::vector< storage::BtrfsSubvolume const * >::allocator_type *", 0, 0, (void*)0, 0};
+              static swig_type_info _swigt__p_std__allocatorT_storage__BtrfsSubvolume_p_t = {
+         "_p_std__allocatorT_storage__BtrfsSubvolume_p_t", "std::vector< storage::BtrfsSubvolume * >::allocator_type *|std::allocator< storage::BtrfsSubvolume * > *", 0, 0, (void*)0, 0};
+              static swig_type_info _swigt__p_std__allocatorT_storage__CompoundAction_const_p_t = {
+         "_p_std__allocatorT_storage__CompoundAction_const_p_t", "std::allocator< storage::CompoundAction const * > *|std::vector< storage::CompoundAction const * >::allocator_type *", 0, 0, (void*)0, 0};
+              static swig_type_info _swigt__p_std__allocatorT_storage__CompoundAction_p_t = {
+         "_p_std__allocatorT_storage__CompoundAction_p_t", "std::vector< storage::CompoundAction * >::allocator_type *|std::allocator< storage::CompoundAction * > *", 0, 0, (void*)0, 0};
+              static swig_type_info _swigt__p_std__allocatorT_storage__Dasd_const_p_t = {
+         "_p_std__allocatorT_storage__Dasd_const_p_t", "std::vector< storage::Dasd const * >::allocator_type *|std::allocator< storage::Dasd const * > *", 0, 0, (void*)0, 0};
+              static swig_type_info _swigt__p_std__allocatorT_storage__Dasd_p_t = {
+         "_p_std__allocatorT_storage__Dasd_p_t", "std::vector< storage::Dasd * >::allocator_type *|std::allocator< storage::Dasd * > *", 0, 0, (void*)0, 0};
+              static swig_type_info _swigt__p_std__allocatorT_storage__Device_const_p_t = {
+         "_p_std__allocatorT_storage__Device_const_p_t", "std::vector< storage::Device const * >::allocator_type *|std::allocator< storage::Device const * > *", 0, 0, (void*)0, 0};
+              static swig_type_info _swigt__p_std__allocatorT_storage__Device_p_t = {
+         "_p_std__allocatorT_storage__Device_p_t", "std::vector< storage::Device * >::allocator_type *|std::allocator< storage::Device * > *", 0, 0, (void*)0, 0};
+              static swig_type_info _swigt__p_std__allocatorT_storage__Disk_const_p_t = {
+         "_p_std__allocatorT_storage__Disk_const_p_t", "std::vector< storage::Disk const * >::allocator_type *|std::allocator< storage::Disk const * > *", 0, 0, (void*)0, 0};
+              static swig_type_info _swigt__p_std__allocatorT_storage__Disk_p_t = {
+         "_p_std__allocatorT_storage__Disk_p_t", "std::vector< storage::Disk * >::allocator_type *|std::allocator< storage::Disk * > *", 0, 0, (void*)0, 0};
+              static swig_type_info _swigt__p_std__allocatorT_storage__DmRaid_const_p_t = {
+         "_p_std__allocatorT_storage__DmRaid_const_p_t", "std::vector< storage::DmRaid const * >::allocator_type *|std::allocator< storage::DmRaid const * > *", 0, 0, (void*)0, 0};
+              static swig_type_info _swigt__p_std__allocatorT_storage__DmRaid_p_t = {
+         "_p_std__allocatorT_storage__DmRaid_p_t", "std::vector< storage::DmRaid * >::allocator_type *|std::allocator< storage::DmRaid * > *", 0, 0, (void*)0, 0};
+              static swig_type_info _swigt__p_std__allocatorT_storage__Encryption_const_p_t = {
+         "_p_std__allocatorT_storage__Encryption_const_p_t", "std::allocator< storage::Encryption const * > *|std::vector< storage::Encryption const * >::allocator_type *", 0, 0, (void*)0, 0};
+              static swig_type_info _swigt__p_std__allocatorT_storage__Encryption_p_t = {
+         "_p_std__allocatorT_storage__Encryption_p_t", "std::vector< storage::Encryption * >::allocator_type *|std::allocator< storage::Encryption * > *", 0, 0, (void*)0, 0};
+              static swig_type_info _swigt__p_std__allocatorT_storage__Filesystem_const_p_t = {
+         "_p_std__allocatorT_storage__Filesystem_const_p_t", "std::allocator< storage::Filesystem const * > *|std::vector< storage::Filesystem const * >::allocator_type *", 0, 0, (void*)0, 0};
+              static swig_type_info _swigt__p_std__allocatorT_storage__Filesystem_p_t = {
+         "_p_std__allocatorT_storage__Filesystem_p_t", "std::vector< storage::Filesystem * >::allocator_type *|std::allocator< storage::Filesystem * > *", 0, 0, (void*)0, 0};
+              static swig_type_info _swigt__p_std__allocatorT_storage__Holder_const_p_t = {
+         "_p_std__allocatorT_storage__Holder_const_p_t", "std::vector< storage::Holder const * >::allocator_type *|std::allocator< storage::Holder const * > *", 0, 0, (void*)0, 0};
+              static swig_type_info _swigt__p_std__allocatorT_storage__Holder_p_t = {
+         "_p_std__allocatorT_storage__Holder_p_t", "std::vector< storage::Holder * >::allocator_type *|std::allocator< storage::Holder * > *", 0, 0, (void*)0, 0};
+              static swig_type_info _swigt__p_std__allocatorT_storage__Luks_const_p_t = {
+         "_p_std__allocatorT_storage__Luks_const_p_t", "std::vector< storage::Luks const * >::allocator_type *|std::allocator< storage::Luks const * > *", 0, 0, (void*)0, 0};
+              static swig_type_info _swigt__p_std__allocatorT_storage__Luks_p_t = {
+         "_p_std__allocatorT_storage__Luks_p_t", "std::vector< storage::Luks * >::allocator_type *|std::allocator< storage::Luks * > *", 0, 0, (void*)0, 0};
+              static swig_type_info _swigt__p_std__allocatorT_storage__LvmLv_const_p_t = {
+         "_p_std__allocatorT_storage__LvmLv_const_p_t", "std::allocator< storage::LvmLv const * > *|std::vector< storage::LvmLv const * >::allocator_type *", 0, 0, (void*)0, 0};
+              static swig_type_info _swigt__p_std__allocatorT_storage__LvmLv_p_t = {
+         "_p_std__allocatorT_storage__LvmLv_p_t", "std::vector< storage::LvmLv * >::allocator_type *|std::allocator< storage::LvmLv * > *", 0, 0, (void*)0, 0};
+              static swig_type_info _swigt__p_std__allocatorT_storage__LvmPv_const_p_t = {
+         "_p_std__allocatorT_storage__LvmPv_const_p_t", "std::allocator< storage::LvmPv const * > *|std::vector< storage::LvmPv const * >::allocator_type *", 0, 0, (void*)0, 0};
+              static swig_type_info _swigt__p_std__allocatorT_storage__LvmPv_p_t = {
+         "_p_std__allocatorT_storage__LvmPv_p_t", "std::vector< storage::LvmPv * >::allocator_type *|std::allocator< storage::LvmPv * > *", 0, 0, (void*)0, 0};
+              static swig_type_info _swigt__p_std__allocatorT_storage__LvmVg_const_p_t = {
+         "_p_std__allocatorT_storage__LvmVg_const_p_t", "std::allocator< storage::LvmVg const * > *|std::vector< storage::LvmVg const * >::allocator_type *", 0, 0, (void*)0, 0};
+              static swig_type_info _swigt__p_std__allocatorT_storage__LvmVg_p_t = {
+         "_p_std__allocatorT_storage__LvmVg_p_t", "std::vector< storage::LvmVg * >::allocator_type *|std::allocator< storage::LvmVg * > *", 0, 0, (void*)0, 0};
+              static swig_type_info _swigt__p_std__allocatorT_storage__MdContainer_const_p_t = {
+         "_p_std__allocatorT_storage__MdContainer_const_p_t", "std::allocator< storage::MdContainer const * > *|std::vector< storage::MdContainer const * >::allocator_type *", 0, 0, (void*)0, 0};
+              static swig_type_info _swigt__p_std__allocatorT_storage__MdContainer_p_t = {
+         "_p_std__allocatorT_storage__MdContainer_p_t", "std::allocator< storage::MdContainer * > *|std::vector< storage::MdContainer * >::allocator_type *", 0, 0, (void*)0, 0};
+              static swig_type_info _swigt__p_std__allocatorT_storage__MdMember_const_p_t = {
+         "_p_std__allocatorT_storage__MdMember_const_p_t", "std::vector< storage::MdMember const * >::allocator_type *|std::allocator< storage::MdMember const * > *", 0, 0, (void*)0, 0};
+              static swig_type_info _swigt__p_std__allocatorT_storage__MdMember_p_t = {
+         "_p_std__allocatorT_storage__MdMember_p_t", "std::vector< storage::MdMember * >::allocator_type *|std::allocator< storage::MdMember * > *", 0, 0, (void*)0, 0};
+              static swig_type_info _swigt__p_std__allocatorT_storage__MdParity_t = {
+         "_p_std__allocatorT_storage__MdParity_t", "std::allocator< enum storage::MdParity > *|std::vector< enum storage::MdParity >::allocator_type *", 0, 0, (void*)0, 0};
+              static swig_type_info _swigt__p_std__allocatorT_storage__Md_const_p_t = {
+         "_p_std__allocatorT_storage__Md_const_p_t", "std::vector< storage::Md const * >::allocator_type *|std::allocator< storage::Md const * > *", 0, 0, (void*)0, 0};
+              static swig_type_info _swigt__p_std__allocatorT_storage__Md_p_t = {
+         "_p_std__allocatorT_storage__Md_p_t", "std::vector< storage::Md * >::allocator_type *|std::allocator< storage::Md * > *", 0, 0, (void*)0, 0};
+              static swig_type_info _swigt__p_std__allocatorT_storage__MountByType_t = {
+         "_p_std__allocatorT_storage__MountByType_t", "std::vector< enum storage::MountByType >::allocator_type *|std::allocator< enum storage::MountByType > *", 0, 0, (void*)0, 0};
+              static swig_type_info _swigt__p_std__allocatorT_storage__MountPoint_const_p_t = {
+         "_p_std__allocatorT_storage__MountPoint_const_p_t", "std::allocator< storage::MountPoint const * > *|std::vector< storage::MountPoint const * >::allocator_type *", 0, 0, (void*)0, 0};
+              static swig_type_info _swigt__p_std__allocatorT_storage__MountPoint_p_t = {
+         "_p_std__allocatorT_storage__MountPoint_p_t", "std::vector< storage::MountPoint * >::allocator_type *|std::allocator< storage::MountPoint * > *", 0, 0, (void*)0, 0};
+              static swig_type_info _swigt__p_std__allocatorT_storage__Mountable_const_p_t = {
+         "_p_std__allocatorT_storage__Mountable_const_p_t", "std::vector< storage::Mountable const * >::allocator_type *|std::allocator< storage::Mountable const * > *", 0, 0, (void*)0, 0};
+              static swig_type_info _swigt__p_std__allocatorT_storage__Mountable_p_t = {
+         "_p_std__allocatorT_storage__Mountable_p_t", "std::vector< storage::Mountable * >::allocator_type *|std::allocator< storage::Mountable * > *", 0, 0, (void*)0, 0};
+              static swig_type_info _swigt__p_std__allocatorT_storage__Multipath_const_p_t = {
+         "_p_std__allocatorT_storage__Multipath_const_p_t", "std::vector< storage::Multipath const * >::allocator_type *|std::allocator< storage::Multipath const * > *", 0, 0, (void*)0, 0};
+              static swig_type_info _swigt__p_std__allocatorT_storage__Multipath_p_t = {
+         "_p_std__allocatorT_storage__Multipath_p_t", "std::vector< storage::Multipath * >::allocator_type *|std::allocator< storage::Multipath * > *", 0, 0, (void*)0, 0};
+              static swig_type_info _swigt__p_std__allocatorT_storage__Nfs_const_p_t = {
+         "_p_std__allocatorT_storage__Nfs_const_p_t", "std::vector< storage::Nfs const * >::allocator_type *|std::allocator< storage::Nfs const * > *", 0, 0, (void*)0, 0};
+              static swig_type_info _swigt__p_std__allocatorT_storage__Nfs_p_t = {
+         "_p_std__allocatorT_storage__Nfs_p_t", "std::vector< storage::Nfs * >::allocator_type *|std::allocator< storage::Nfs * > *", 0, 0, (void*)0, 0};
+              static swig_type_info _swigt__p_std__allocatorT_storage__Ntfs_const_p_t = {
+         "_p_std__allocatorT_storage__Ntfs_const_p_t", "std::vector< storage::Ntfs const * >::allocator_type *|std::allocator< storage::Ntfs const * > *", 0, 0, (void*)0, 0};
+              static swig_type_info _swigt__p_std__allocatorT_storage__Ntfs_p_t = {
+         "_p_std__allocatorT_storage__Ntfs_p_t", "std::vector< storage::Ntfs * >::allocator_type *|std::allocator< storage::Ntfs * > *", 0, 0, (void*)0, 0};
+              static swig_type_info _swigt__p_std__allocatorT_storage__PartitionSlot_t = {
+         "_p_std__allocatorT_storage__PartitionSlot_t", "std::allocator< storage::PartitionSlot > *|std::vector< storage::PartitionSlot >::allocator_type *", 0, 0, (void*)0, 0};
+              static swig_type_info _swigt__p_std__allocatorT_storage__Partition_const_p_t = {
+         "_p_std__allocatorT_storage__Partition_const_p_t", "std::vector< storage::Partition const * >::allocator_type *|std::allocator< storage::Partition const * > *", 0, 0, (void*)0, 0};
+              static swig_type_info _swigt__p_std__allocatorT_storage__Partition_p_t = {
+         "_p_std__allocatorT_storage__Partition_p_t", "std::vector< storage::Partition * >::allocator_type *|std::allocator< storage::Partition * > *", 0, 0, (void*)0, 0};
+              static swig_type_info _swigt__p_std__allocatorT_storage__Partitionable_const_p_t = {
+         "_p_std__allocatorT_storage__Partitionable_const_p_t", "std::vector< storage::Partitionable const * >::allocator_type *|std::allocator< storage::Partitionable const * > *", 0, 0, (void*)0, 0};
+              static swig_type_info _swigt__p_std__allocatorT_storage__Partitionable_p_t = {
+         "_p_std__allocatorT_storage__Partitionable_p_t", "std::allocator< storage::Partitionable * > *|std::vector< storage::Partitionable * >::allocator_type *", 0, 0, (void*)0, 0};
+              static swig_type_info _swigt__p_std__allocatorT_storage__PtType_t = {
+         "_p_std__allocatorT_storage__PtType_t", "std::vector< enum storage::PtType >::allocator_type *|std::allocator< enum storage::PtType > *", 0, 0, (void*)0, 0};
+              static swig_type_info _swigt__p_std__allocatorT_storage__SimpleEtcCrypttabEntry_t = {
+         "_p_std__allocatorT_storage__SimpleEtcCrypttabEntry_t", "std::vector< storage::SimpleEtcCrypttabEntry >::allocator_type *|std::allocator< storage::SimpleEtcCrypttabEntry > *", 0, 0, (void*)0, 0};
+              static swig_type_info _swigt__p_std__allocatorT_storage__SimpleEtcFstabEntry_t = {
+         "_p_std__allocatorT_storage__SimpleEtcFstabEntry_t", "std::allocator< storage::SimpleEtcFstabEntry > *|std::vector< storage::SimpleEtcFstabEntry >::allocator_type *", 0, 0, (void*)0, 0};
+              static swig_type_info _swigt__p_std__allocatorT_storage__StrayBlkDevice_const_p_t = {
+         "_p_std__allocatorT_storage__StrayBlkDevice_const_p_t", "std::allocator< storage::StrayBlkDevice const * > *|std::vector< storage::StrayBlkDevice const * >::allocator_type *", 0, 0, (void*)0, 0};
+              static swig_type_info _swigt__p_std__allocatorT_storage__StrayBlkDevice_p_t = {
+         "_p_std__allocatorT_storage__StrayBlkDevice_p_t", "std::vector< storage::StrayBlkDevice * >::allocator_type *|std::allocator< storage::StrayBlkDevice * > *", 0, 0, (void*)0, 0};
+              static swig_type_info _swigt__p_std__allocatorT_storage__Swap_const_p_t = {
+         "_p_std__allocatorT_storage__Swap_const_p_t", "std::vector< storage::Swap const * >::allocator_type *|std::allocator< storage::Swap const * > *", 0, 0, (void*)0, 0};
+              static swig_type_info _swigt__p_std__allocatorT_storage__Swap_p_t = {
+         "_p_std__allocatorT_storage__Swap_p_t", "std::vector< storage::Swap * >::allocator_type *|std::allocator< storage::Swap * > *", 0, 0, (void*)0, 0};
+              static swig_type_info _swigt__p_std__exception = {
+         "_p_std__exception", "std::exception *", 0, 0, (void*)0, 0};
+              static swig_type_info _swigt__p_std__invalid_argument = {
+         "_p_std__invalid_argument", "std::invalid_argument *", 0, 0, (void*)0, 0};
+              static swig_type_info _swigt__p_std__lessT_std__string_t = {
+         "_p_std__lessT_std__string_t", "std::less< std::string > *", 0, 0, (void*)0, 0};
+              static swig_type_info _swigt__p_std__mapT_std__string_std__string_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_std__string_t_t_t = {
+         "_p_std__mapT_std__string_std__string_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_std__string_t_t_t", "std::map< std::string,std::string > *|std::map< std::string,std::string,std::less< std::string >,std::allocator< std::pair< std::string const,std::string > > > *", 0, 0, (void*)0, 0};
+              static swig_type_info _swigt__p_std__ostream = {
+         "_p_std__ostream", "std::ostream *", 0, 0, (void*)0, 0};
+              static swig_type_info _swigt__p_std__pairT_bool_std__string_t = {
+         "_p_std__pairT_bool_std__string_t", "std::pair< bool,std::string > *", 0, 0, (void*)0, 0};
+              static swig_type_info _swigt__p_std__vectorT_std__string_std__allocatorT_std__string_t_t = {
+         "_p_std__vectorT_std__string_std__allocatorT_std__string_t_t", "std::vector< std::string,std::allocator< std::string > > *|std::vector< std::string > *", 0, 0, (void*)0, 0};
+              static swig_type_info _swigt__p_std__vectorT_storage__Action__Base_const_p_std__allocatorT_storage__Action__Base_const_p_t_t = {
+         "_p_std__vectorT_storage__Action__Base_const_p_std__allocatorT_storage__Action__Base_const_p_t_t", "std::vector< storage::Action::Base const *,std::allocator< storage::Action::Base const * > > *", 0, 0, (void*)0, 0};
+              static swig_type_info _swigt__p_std__vectorT_storage__BcacheCset_const_p_std__allocatorT_storage__BcacheCset_const_p_t_t = {
+         "_p_std__vectorT_storage__BcacheCset_const_p_std__allocatorT_storage__BcacheCset_const_p_t_t", "std::vector< storage::BcacheCset const *,std::allocator< storage::BcacheCset const * > > *|std::vector< storage::BcacheCset const * > *", 0, 0, (void*)0, 0};
+              static swig_type_info _swigt__p_std__vectorT_storage__BcacheCset_p_std__allocatorT_storage__BcacheCset_p_t_t = {
+         "_p_std__vectorT_storage__BcacheCset_p_std__allocatorT_storage__BcacheCset_p_t_t", "std::vector< storage::BcacheCset *,std::allocator< storage::BcacheCset * > > *|std::vector< storage::BcacheCset * > *", 0, 0, (void*)0, 0};
+              static swig_type_info _swigt__p_std__vectorT_storage__Bcache_const_p_std__allocatorT_storage__Bcache_const_p_t_t = {
+         "_p_std__vectorT_storage__Bcache_const_p_std__allocatorT_storage__Bcache_const_p_t_t", "std::vector< storage::Bcache const *,std::allocator< storage::Bcache const * > > *|std::vector< storage::Bcache const * > *", 0, 0, (void*)0, 0};
+              static swig_type_info _swigt__p_std__vectorT_storage__Bcache_p_std__allocatorT_storage__Bcache_p_t_t = {
+         "_p_std__vectorT_storage__Bcache_p_std__allocatorT_storage__Bcache_p_t_t", "std::vector< storage::Bcache *,std::allocator< storage::Bcache * > > *|std::vector< storage::Bcache * > *", 0, 0, (void*)0, 0};
+              static swig_type_info _swigt__p_std__vectorT_storage__BlkDevice_const_p_std__allocatorT_storage__BlkDevice_const_p_t_t = {
+         "_p_std__vectorT_storage__BlkDevice_const_p_std__allocatorT_storage__BlkDevice_const_p_t_t", "std::vector< storage::BlkDevice const * > *|std::vector< storage::BlkDevice const *,std::allocator< storage::BlkDevice const * > > *", 0, 0, (void*)0, 0};
+              static swig_type_info _swigt__p_std__vectorT_storage__BlkDevice_p_std__allocatorT_storage__BlkDevice_p_t_t = {
+         "_p_std__vectorT_storage__BlkDevice_p_std__allocatorT_storage__BlkDevice_p_t_t", "std::vector< storage::BlkDevice * > *|std::vector< storage::BlkDevice *,std::allocator< storage::BlkDevice * > > *", 0, 0, (void*)0, 0};
+              static swig_type_info _swigt__p_std__vectorT_storage__BlkFilesystem_const_p_std__allocatorT_storage__BlkFilesystem_const_p_t_t = {
+         "_p_std__vectorT_storage__BlkFilesystem_const_p_std__allocatorT_storage__BlkFilesystem_const_p_t_t", "std::vector< storage::BlkFilesystem const * > *|std::vector< storage::BlkFilesystem const *,std::allocator< storage::BlkFilesystem const * > > *", 0, 0, (void*)0, 0};
+              static swig_type_info _swigt__p_std__vectorT_storage__BlkFilesystem_p_std__allocatorT_storage__BlkFilesystem_p_t_t = {
+         "_p_std__vectorT_storage__BlkFilesystem_p_std__allocatorT_storage__BlkFilesystem_p_t_t", "std::vector< storage::BlkFilesystem *,std::allocator< storage::BlkFilesystem * > > *|std::vector< storage::BlkFilesystem * > *", 0, 0, (void*)0, 0};
+              static swig_type_info _swigt__p_std__vectorT_storage__BtrfsSubvolume_const_p_std__allocatorT_storage__BtrfsSubvolume_const_p_t_t = {
+         "_p_std__vectorT_storage__BtrfsSubvolume_const_p_std__allocatorT_storage__BtrfsSubvolume_const_p_t_t", "std::vector< storage::BtrfsSubvolume const * > *|std::vector< storage::BtrfsSubvolume const *,std::allocator< storage::BtrfsSubvolume const * > > *", 0, 0, (void*)0, 0};
+              static swig_type_info _swigt__p_std__vectorT_storage__BtrfsSubvolume_p_std__allocatorT_storage__BtrfsSubvolume_p_t_t = {
+         "_p_std__vectorT_storage__BtrfsSubvolume_p_std__allocatorT_storage__BtrfsSubvolume_p_t_t", "std::vector< storage::BtrfsSubvolume * > *|std::vector< storage::BtrfsSubvolume *,std::allocator< storage::BtrfsSubvolume * > > *", 0, 0, (void*)0, 0};
+              static swig_type_info _swigt__p_std__vectorT_storage__CompoundAction_const_p_std__allocatorT_storage__CompoundAction_const_p_t_t = {
+         "_p_std__vectorT_storage__CompoundAction_const_p_std__allocatorT_storage__CompoundAction_const_p_t_t", "std::vector< storage::CompoundAction const * > *|std::vector< storage::CompoundAction const *,std::allocator< storage::CompoundAction const * > > *", 0, 0, (void*)0, 0};
+              static swig_type_info _swigt__p_std__vectorT_storage__CompoundAction_p_std__allocatorT_storage__CompoundAction_p_t_t = {
+         "_p_std__vectorT_storage__CompoundAction_p_std__allocatorT_storage__CompoundAction_p_t_t", "std::vector< storage::CompoundAction *,std::allocator< storage::CompoundAction * > > *|std::vector< storage::CompoundAction * > *", 0, 0, (void*)0, 0};
+              static swig_type_info _swigt__p_std__vectorT_storage__Dasd_const_p_std__allocatorT_storage__Dasd_const_p_t_t = {
+         "_p_std__vectorT_storage__Dasd_const_p_std__allocatorT_storage__Dasd_const_p_t_t", "std::vector< storage::Dasd const *,std::allocator< storage::Dasd const * > > *|std::vector< storage::Dasd const * > *", 0, 0, (void*)0, 0};
+              static swig_type_info _swigt__p_std__vectorT_storage__Dasd_p_std__allocatorT_storage__Dasd_p_t_t = {
+         "_p_std__vectorT_storage__Dasd_p_std__allocatorT_storage__Dasd_p_t_t", "std::vector< storage::Dasd *,std::allocator< storage::Dasd * > > *|std::vector< storage::Dasd * > *", 0, 0, (void*)0, 0};
+              static swig_type_info _swigt__p_std__vectorT_storage__Device_const_p_std__allocatorT_storage__Device_const_p_t_t = {
+         "_p_std__vectorT_storage__Device_const_p_std__allocatorT_storage__Device_const_p_t_t", "std::vector< storage::Device const *,std::allocator< storage::Device const * > > *|std::vector< storage::Device const * > *", 0, 0, (void*)0, 0};
+              static swig_type_info _swigt__p_std__vectorT_storage__Device_p_std__allocatorT_storage__Device_p_t_t = {
+         "_p_std__vectorT_storage__Device_p_std__allocatorT_storage__Device_p_t_t", "std::vector< storage::Device *,std::allocator< storage::Device * > > *|std::vector< storage::Device * > *", 0, 0, (void*)0, 0};
+              static swig_type_info _swigt__p_std__vectorT_storage__Disk_const_p_std__allocatorT_storage__Disk_const_p_t_t = {
+         "_p_std__vectorT_storage__Disk_const_p_std__allocatorT_storage__Disk_const_p_t_t", "std::vector< storage::Disk const *,std::allocator< storage::Disk const * > > *|std::vector< storage::Disk const * > *", 0, 0, (void*)0, 0};
+              static swig_type_info _swigt__p_std__vectorT_storage__Disk_p_std__allocatorT_storage__Disk_p_t_t = {
+         "_p_std__vectorT_storage__Disk_p_std__allocatorT_storage__Disk_p_t_t", "std::vector< storage::Disk *,std::allocator< storage::Disk * > > *|std::vector< storage::Disk * > *", 0, 0, (void*)0, 0};
+              static swig_type_info _swigt__p_std__vectorT_storage__DmRaid_const_p_std__allocatorT_storage__DmRaid_const_p_t_t = {
+         "_p_std__vectorT_storage__DmRaid_const_p_std__allocatorT_storage__DmRaid_const_p_t_t", "std::vector< storage::DmRaid const *,std::allocator< storage::DmRaid const * > > *|std::vector< storage::DmRaid const * > *", 0, 0, (void*)0, 0};
+              static swig_type_info _swigt__p_std__vectorT_storage__DmRaid_p_std__allocatorT_storage__DmRaid_p_t_t = {
+         "_p_std__vectorT_storage__DmRaid_p_std__allocatorT_storage__DmRaid_p_t_t", "std::vector< storage::DmRaid *,std::allocator< storage::DmRaid * > > *|std::vector< storage::DmRaid * > *", 0, 0, (void*)0, 0};
+              static swig_type_info _swigt__p_std__vectorT_storage__Encryption_const_p_std__allocatorT_storage__Encryption_const_p_t_t = {
+         "_p_std__vectorT_storage__Encryption_const_p_std__allocatorT_storage__Encryption_const_p_t_t", "std::vector< storage::Encryption const *,std::allocator< storage::Encryption const * > > *|std::vector< storage::Encryption const * > *", 0, 0, (void*)0, 0};
+              static swig_type_info _swigt__p_std__vectorT_storage__Encryption_p_std__allocatorT_storage__Encryption_p_t_t = {
+         "_p_std__vectorT_storage__Encryption_p_std__allocatorT_storage__Encryption_p_t_t", "std::vector< storage::Encryption *,std::allocator< storage::Encryption * > > *|std::vector< storage::Encryption * > *", 0, 0, (void*)0, 0};
+              static swig_type_info _swigt__p_std__vectorT_storage__Filesystem_const_p_std__allocatorT_storage__Filesystem_const_p_t_t = {
+         "_p_std__vectorT_storage__Filesystem_const_p_std__allocatorT_storage__Filesystem_const_p_t_t", "std::vector< storage::Filesystem const *,std::allocator< storage::Filesystem const * > > *|std::vector< storage::Filesystem const * > *", 0, 0, (void*)0, 0};
+              static swig_type_info _swigt__p_std__vectorT_storage__Filesystem_p_std__allocatorT_storage__Filesystem_p_t_t = {
+         "_p_std__vectorT_storage__Filesystem_p_std__allocatorT_storage__Filesystem_p_t_t", "std::vector< storage::Filesystem *,std::allocator< storage::Filesystem * > > *|std::vector< storage::Filesystem * > *", 0, 0, (void*)0, 0};
+              static swig_type_info _swigt__p_std__vectorT_storage__Gpt_const_p_std__allocatorT_storage__Gpt_const_p_t_t = {
+         "_p_std__vectorT_storage__Gpt_const_p_std__allocatorT_storage__Gpt_const_p_t_t", "std::vector< storage::Gpt const *,std::allocator< storage::Gpt const * > > *", 0, 0, (void*)0, 0};
+              static swig_type_info _swigt__p_std__vectorT_storage__Gpt_p_std__allocatorT_storage__Gpt_p_t_t = {
+         "_p_std__vectorT_storage__Gpt_p_std__allocatorT_storage__Gpt_p_t_t", "std::vector< storage::Gpt *,std::allocator< storage::Gpt * > > *", 0, 0, (void*)0, 0};
+              static swig_type_info _swigt__p_std__vectorT_storage__Holder_const_p_std__allocatorT_storage__Holder_const_p_t_t = {
+         "_p_std__vectorT_storage__Holder_const_p_std__allocatorT_storage__Holder_const_p_t_t", "std::vector< storage::Holder const *,std::allocator< storage::Holder const * > > *|std::vector< storage::Holder const * > *", 0, 0, (void*)0, 0};
+              static swig_type_info _swigt__p_std__vectorT_storage__Holder_p_std__allocatorT_storage__Holder_p_t_t = {
+         "_p_std__vectorT_storage__Holder_p_std__allocatorT_storage__Holder_p_t_t", "std::vector< storage::Holder *,std::allocator< storage::Holder * > > *|std::vector< storage::Holder * > *", 0, 0, (void*)0, 0};
+              static swig_type_info _swigt__p_std__vectorT_storage__Luks_const_p_std__allocatorT_storage__Luks_const_p_t_t = {
+         "_p_std__vectorT_storage__Luks_const_p_std__allocatorT_storage__Luks_const_p_t_t", "std::vector< storage::Luks const *,std::allocator< storage::Luks const * > > *|std::vector< storage::Luks const * > *", 0, 0, (void*)0, 0};
+              static swig_type_info _swigt__p_std__vectorT_storage__Luks_p_std__allocatorT_storage__Luks_p_t_t = {
+         "_p_std__vectorT_storage__Luks_p_std__allocatorT_storage__Luks_p_t_t", "std::vector< storage::Luks *,std::allocator< storage::Luks * > > *|std::vector< storage::Luks * > *", 0, 0, (void*)0, 0};
+              static swig_type_info _swigt__p_std__vectorT_storage__LvmLv_const_p_std__allocatorT_storage__LvmLv_const_p_t_t = {
+         "_p_std__vectorT_storage__LvmLv_const_p_std__allocatorT_storage__LvmLv_const_p_t_t", "std::vector< storage::LvmLv const *,std::allocator< storage::LvmLv const * > > *|std::vector< storage::LvmLv const * > *", 0, 0, (void*)0, 0};
+              static swig_type_info _swigt__p_std__vectorT_storage__LvmLv_p_std__allocatorT_storage__LvmLv_p_t_t = {
+         "_p_std__vectorT_storage__LvmLv_p_std__allocatorT_storage__LvmLv_p_t_t", "std::vector< storage::LvmLv *,std::allocator< storage::LvmLv * > > *|std::vector< storage::LvmLv * > *", 0, 0, (void*)0, 0};
+              static swig_type_info _swigt__p_std__vectorT_storage__LvmPv_const_p_std__allocatorT_storage__LvmPv_const_p_t_t = {
+         "_p_std__vectorT_storage__LvmPv_const_p_std__allocatorT_storage__LvmPv_const_p_t_t", "std::vector< storage::LvmPv const *,std::allocator< storage::LvmPv const * > > *|std::vector< storage::LvmPv const * > *", 0, 0, (void*)0, 0};
+              static swig_type_info _swigt__p_std__vectorT_storage__LvmPv_p_std__allocatorT_storage__LvmPv_p_t_t = {
+         "_p_std__vectorT_storage__LvmPv_p_std__allocatorT_storage__LvmPv_p_t_t", "std::vector< storage::LvmPv *,std::allocator< storage::LvmPv * > > *|std::vector< storage::LvmPv * > *", 0, 0, (void*)0, 0};
+              static swig_type_info _swigt__p_std__vectorT_storage__LvmVg_const_p_std__allocatorT_storage__LvmVg_const_p_t_t = {
+         "_p_std__vectorT_storage__LvmVg_const_p_std__allocatorT_storage__LvmVg_const_p_t_t", "std::vector< storage::LvmVg const *,std::allocator< storage::LvmVg const * > > *|std::vector< storage::LvmVg const * > *", 0, 0, (void*)0, 0};
+              static swig_type_info _swigt__p_std__vectorT_storage__LvmVg_p_std__allocatorT_storage__LvmVg_p_t_t = {
+         "_p_std__vectorT_storage__LvmVg_p_std__allocatorT_storage__LvmVg_p_t_t", "std::vector< storage::LvmVg * > *|std::vector< storage::LvmVg *,std::allocator< storage::LvmVg * > > *", 0, 0, (void*)0, 0};
+              static swig_type_info _swigt__p_std__vectorT_storage__MdContainer_const_p_std__allocatorT_storage__MdContainer_const_p_t_t = {
+         "_p_std__vectorT_storage__MdContainer_const_p_std__allocatorT_storage__MdContainer_const_p_t_t", "std::vector< storage::MdContainer const *,std::allocator< storage::MdContainer const * > > *|std::vector< storage::MdContainer const * > *", 0, 0, (void*)0, 0};
+              static swig_type_info _swigt__p_std__vectorT_storage__MdContainer_p_std__allocatorT_storage__MdContainer_p_t_t = {
+         "_p_std__vectorT_storage__MdContainer_p_std__allocatorT_storage__MdContainer_p_t_t", "std::vector< storage::MdContainer *,std::allocator< storage::MdContainer * > > *|std::vector< storage::MdContainer * > *", 0, 0, (void*)0, 0};
+              static swig_type_info _swigt__p_std__vectorT_storage__MdMember_const_p_std__allocatorT_storage__MdMember_const_p_t_t = {
+         "_p_std__vectorT_storage__MdMember_const_p_std__allocatorT_storage__MdMember_const_p_t_t", "std::vector< storage::MdMember const * > *|std::vector< storage::MdMember const *,std::allocator< storage::MdMember const * > > *", 0, 0, (void*)0, 0};
+              static swig_type_info _swigt__p_std__vectorT_storage__MdMember_p_std__allocatorT_storage__MdMember_p_t_t = {
+         "_p_std__vectorT_storage__MdMember_p_std__allocatorT_storage__MdMember_p_t_t", "std::vector< storage::MdMember *,std::allocator< storage::MdMember * > > *|std::vector< storage::MdMember * > *", 0, 0, (void*)0, 0};
+              static swig_type_info _swigt__p_std__vectorT_storage__MdParity_std__allocatorT_storage__MdParity_t_t = {
+         "_p_std__vectorT_storage__MdParity_std__allocatorT_storage__MdParity_t_t", "std::vector< storage::MdParity,std::allocator< storage::MdParity > > *|std::vector< enum storage::MdParity > *|std::vector< storage::MdParity > *|std::vector< enum storage::MdParity,std::allocator< enum storage::MdParity > > *", 0, 0, (void*)0, 0};
+              static swig_type_info _swigt__p_std__vectorT_storage__Md_const_p_std__allocatorT_storage__Md_const_p_t_t = {
+         "_p_std__vectorT_storage__Md_const_p_std__allocatorT_storage__Md_const_p_t_t", "std::vector< storage::Md const *,std::allocator< storage::Md const * > > *|std::vector< storage::Md const * > *", 0, 0, (void*)0, 0};
+              static swig_type_info _swigt__p_std__vectorT_storage__Md_p_std__allocatorT_storage__Md_p_t_t = {
+         "_p_std__vectorT_storage__Md_p_std__allocatorT_storage__Md_p_t_t", "std::vector< storage::Md *,std::allocator< storage::Md * > > *|std::vector< storage::Md * > *", 0, 0, (void*)0, 0};
+              static swig_type_info _swigt__p_std__vectorT_storage__MountByType_std__allocatorT_storage__MountByType_t_t = {
+         "_p_std__vectorT_storage__MountByType_std__allocatorT_storage__MountByType_t_t", "std::vector< enum storage::MountByType,std::allocator< enum storage::MountByType > > *|std::vector< enum storage::MountByType > *|std::vector< storage::MountByType > *|std::vector< storage::MountByType,std::allocator< storage::MountByType > > *", 0, 0, (void*)0, 0};
+              static swig_type_info _swigt__p_std__vectorT_storage__MountPoint_const_p_std__allocatorT_storage__MountPoint_const_p_t_t = {
+         "_p_std__vectorT_storage__MountPoint_const_p_std__allocatorT_storage__MountPoint_const_p_t_t", "std::vector< storage::MountPoint const *,std::allocator< storage::MountPoint const * > > *|std::vector< storage::MountPoint const * > *", 0, 0, (void*)0, 0};
+              static swig_type_info _swigt__p_std__vectorT_storage__MountPoint_p_std__allocatorT_storage__MountPoint_p_t_t = {
+         "_p_std__vectorT_storage__MountPoint_p_std__allocatorT_storage__MountPoint_p_t_t", "std::vector< storage::MountPoint *,std::allocator< storage::MountPoint * > > *|std::vector< storage::MountPoint * > *", 0, 0, (void*)0, 0};
+              static swig_type_info _swigt__p_std__vectorT_storage__Mountable_const_p_std__allocatorT_storage__Mountable_const_p_t_t = {
+         "_p_std__vectorT_storage__Mountable_const_p_std__allocatorT_storage__Mountable_const_p_t_t", "std::vector< storage::Mountable const * > *|std::vector< storage::Mountable const *,std::allocator< storage::Mountable const * > > *", 0, 0, (void*)0, 0};
+              static swig_type_info _swigt__p_std__vectorT_storage__Mountable_p_std__allocatorT_storage__Mountable_p_t_t = {
+         "_p_std__vectorT_storage__Mountable_p_std__allocatorT_storage__Mountable_p_t_t", "std::vector< storage::Mountable * > *|std::vector< storage::Mountable *,std::allocator< storage::Mountable * > > *", 0, 0, (void*)0, 0};
+              static swig_type_info _swigt__p_std__vectorT_storage__Multipath_const_p_std__allocatorT_storage__Multipath_const_p_t_t = {
+         "_p_std__vectorT_storage__Multipath_const_p_std__allocatorT_storage__Multipath_const_p_t_t", "std::vector< storage::Multipath const * > *|std::vector< storage::Multipath const *,std::allocator< storage::Multipath const * > > *", 0, 0, (void*)0, 0};
+              static swig_type_info _swigt__p_std__vectorT_storage__Multipath_p_std__allocatorT_storage__Multipath_p_t_t = {
+         "_p_std__vectorT_storage__Multipath_p_std__allocatorT_storage__Multipath_p_t_t", "std::vector< storage::Multipath * > *|std::vector< storage::Multipath *,std::allocator< storage::Multipath * > > *", 0, 0, (void*)0, 0};
+              static swig_type_info _swigt__p_std__vectorT_storage__Nfs_const_p_std__allocatorT_storage__Nfs_const_p_t_t = {
+         "_p_std__vectorT_storage__Nfs_const_p_std__allocatorT_storage__Nfs_const_p_t_t", "std::vector< storage::Nfs const * > *|std::vector< storage::Nfs const *,std::allocator< storage::Nfs const * > > *", 0, 0, (void*)0, 0};
+              static swig_type_info _swigt__p_std__vectorT_storage__Nfs_p_std__allocatorT_storage__Nfs_p_t_t = {
+         "_p_std__vectorT_storage__Nfs_p_std__allocatorT_storage__Nfs_p_t_t", "std::vector< storage::Nfs *,std::allocator< storage::Nfs * > > *|std::vector< storage::Nfs * > *", 0, 0, (void*)0, 0};
+              static swig_type_info _swigt__p_std__vectorT_storage__Ntfs_const_p_std__allocatorT_storage__Ntfs_const_p_t_t = {
+         "_p_std__vectorT_storage__Ntfs_const_p_std__allocatorT_storage__Ntfs_const_p_t_t", "std::vector< storage::Ntfs const *,std::allocator< storage::Ntfs const * > > *|std::vector< storage::Ntfs const * > *", 0, 0, (void*)0, 0};
+              static swig_type_info _swigt__p_std__vectorT_storage__Ntfs_p_std__allocatorT_storage__Ntfs_p_t_t = {
+         "_p_std__vectorT_storage__Ntfs_p_std__allocatorT_storage__Ntfs_p_t_t", "std::vector< storage::Ntfs *,std::allocator< storage::Ntfs * > > *|std::vector< storage::Ntfs * > *", 0, 0, (void*)0, 0};
+              static swig_type_info _swigt__p_std__vectorT_storage__PartitionSlot_std__allocatorT_storage__PartitionSlot_t_t = {
+         "_p_std__vectorT_storage__PartitionSlot_std__allocatorT_storage__PartitionSlot_t_t", "std::vector< storage::PartitionSlot > *|std::vector< storage::PartitionSlot,std::allocator< storage::PartitionSlot > > *", 0, 0, (void*)0, 0};
+              static swig_type_info _swigt__p_std__vectorT_storage__Partition_const_p_std__allocatorT_storage__Partition_const_p_t_t = {
+         "_p_std__vectorT_storage__Partition_const_p_std__allocatorT_storage__Partition_const_p_t_t", "std::vector< storage::Partition const * > *|std::vector< storage::Partition const *,std::allocator< storage::Partition const * > > *", 0, 0, (void*)0, 0};
+              static swig_type_info _swigt__p_std__vectorT_storage__Partition_p_std__allocatorT_storage__Partition_p_t_t = {
+         "_p_std__vectorT_storage__Partition_p_std__allocatorT_storage__Partition_p_t_t", "std::vector< storage::Partition * > *|std::vector< storage::Partition *,std::allocator< storage::Partition * > > *", 0, 0, (void*)0, 0};
+              static swig_type_info _swigt__p_std__vectorT_storage__Partitionable_const_p_std__allocatorT_storage__Partitionable_const_p_t_t = {
+         "_p_std__vectorT_storage__Partitionable_const_p_std__allocatorT_storage__Partitionable_const_p_t_t", "std::vector< storage::Partitionable const * > *|std::vector< storage::Partitionable const *,std::allocator< storage::Partitionable const * > > *", 0, 0, (void*)0, 0};
+              static swig_type_info _swigt__p_std__vectorT_storage__Partitionable_p_std__allocatorT_storage__Partitionable_p_t_t = {
+         "_p_std__vectorT_storage__Partitionable_p_std__allocatorT_storage__Partitionable_p_t_t", "std::vector< storage::Partitionable *,std::allocator< storage::Partitionable * > > *|std::vector< storage::Partitionable * > *", 0, 0, (void*)0, 0};
+              static swig_type_info _swigt__p_std__vectorT_storage__PtType_std__allocatorT_storage__PtType_t_t = {
+         "_p_std__vectorT_storage__PtType_std__allocatorT_storage__PtType_t_t", "std::vector< storage::PtType,std::allocator< storage::PtType > > *|std::vector< enum storage::PtType > *|std::vector< storage::PtType > *|std::vector< enum storage::PtType,std::allocator< enum storage::PtType > > *", 0, 0, (void*)0, 0};
+              static swig_type_info _swigt__p_std__vectorT_storage__Region_std__allocatorT_storage__Region_t_t = {
+         "_p_std__vectorT_storage__Region_std__allocatorT_storage__Region_t_t", "std::vector< storage::Region,std::allocator< storage::Region > > *", 0, 0, (void*)0, 0};
+              static swig_type_info _swigt__p_std__vectorT_storage__SimpleEtcCrypttabEntry_std__allocatorT_storage__SimpleEtcCrypttabEntry_t_t = {
+         "_p_std__vectorT_storage__SimpleEtcCrypttabEntry_std__allocatorT_storage__SimpleEtcCrypttabEntry_t_t", "std::vector< storage::SimpleEtcCrypttabEntry > *|std::vector< storage::SimpleEtcCrypttabEntry,std::allocator< storage::SimpleEtcCrypttabEntry > > *", 0, 0, (void*)0, 0};
+              static swig_type_info _swigt__p_std__vectorT_storage__SimpleEtcFstabEntry_std__allocatorT_storage__SimpleEtcFstabEntry_t_t = {
+         "_p_std__vectorT_storage__SimpleEtcFstabEntry_std__allocatorT_storage__SimpleEtcFstabEntry_t_t", "std::vector< storage::SimpleEtcFstabEntry > *|std::vector< storage::SimpleEtcFstabEntry,std::allocator< storage::SimpleEtcFstabEntry > > *", 0, 0, (void*)0, 0};
+              static swig_type_info _swigt__p_std__vectorT_storage__StrayBlkDevice_const_p_std__allocatorT_storage__StrayBlkDevice_const_p_t_t = {
+         "_p_std__vectorT_storage__StrayBlkDevice_const_p_std__allocatorT_storage__StrayBlkDevice_const_p_t_t", "std::vector< storage::StrayBlkDevice const * > *|std::vector< storage::StrayBlkDevice const *,std::allocator< storage::StrayBlkDevice const * > > *", 0, 0, (void*)0, 0};
+              static swig_type_info _swigt__p_std__vectorT_storage__StrayBlkDevice_p_std__allocatorT_storage__StrayBlkDevice_p_t_t = {
+         "_p_std__vectorT_storage__StrayBlkDevice_p_std__allocatorT_storage__StrayBlkDevice_p_t_t", "std::vector< storage::StrayBlkDevice * > *|std::vector< storage::StrayBlkDevice *,std::allocator< storage::StrayBlkDevice * > > *", 0, 0, (void*)0, 0};
+              static swig_type_info _swigt__p_std__vectorT_storage__Swap_const_p_std__allocatorT_storage__Swap_const_p_t_t = {
+         "_p_std__vectorT_storage__Swap_const_p_std__allocatorT_storage__Swap_const_p_t_t", "std::vector< storage::Swap const *,std::allocator< storage::Swap const * > > *|std::vector< storage::Swap const * > *", 0, 0, (void*)0, 0};
+              static swig_type_info _swigt__p_std__vectorT_storage__Swap_p_std__allocatorT_storage__Swap_p_t_t = {
+         "_p_std__vectorT_storage__Swap_p_std__allocatorT_storage__Swap_p_t_t", "std::vector< storage::Swap *,std::allocator< storage::Swap * > > *|std::vector< storage::Swap * > *", 0, 0, (void*)0, 0};
+              static swig_type_info _swigt__p_storage__Aborted = {
+         "_p_storage__Aborted", "storage::Aborted *", 0, 0, (void*)0, 0};
+              static swig_type_info _swigt__p_storage__Actiongraph = {
+         "_p_storage__Actiongraph", "storage::Actiongraph *", 0, 0, (void*)0, 0};
+              static swig_type_info _swigt__p_storage__ActivateCallbacks = {
+         "_p_storage__ActivateCallbacks", "storage::ActivateCallbacks *", 0, 0, (void*)0, 0};
+              static swig_type_info _swigt__p_storage__AlignError = {
+         "_p_storage__AlignError", "storage::AlignError *", 0, 0, (void*)0, 0};
+              static swig_type_info _swigt__p_storage__Alignment = {
+         "_p_storage__Alignment", "storage::Alignment *", 0, 0, (void*)0, 0};
+              static swig_type_info _swigt__p_storage__Arch = {
+         "_p_storage__Arch", "storage::Arch *", 0, 0, (void*)0, 0};
+              static swig_type_info _swigt__p_storage__Bcache = {
+         "_p_storage__Bcache", "std::vector< storage::Bcache * >::value_type|std::vector< storage::Bcache const * >::value_type|storage::Bcache *", 0, 0, (void*)0, 0};
+              static swig_type_info _swigt__p_storage__BcacheCset = {
+         "_p_storage__BcacheCset", "std::vector< storage::BcacheCset const * >::value_type|std::vector< storage::BcacheCset * >::value_type|storage::BcacheCset *", 0, 0, (void*)0, 0};
+              static swig_type_info _swigt__p_storage__BlkDevice = {
+         "_p_storage__BlkDevice", "std::vector< storage::BlkDevice * >::value_type|storage::BlkDevice *|std::vector< storage::BlkDevice const * >::value_type", 0, 0, (void*)0, 0};
+              static swig_type_info _swigt__p_storage__BlkFilesystem = {
+         "_p_storage__BlkFilesystem", "storage::BlkFilesystem *|std::vector< storage::BlkFilesystem * >::value_type|std::vector< storage::BlkFilesystem const * >::value_type", 0, 0, (void*)0, 0};
+              static swig_type_info _swigt__p_storage__Btrfs = {
+         "_p_storage__Btrfs", "storage::Btrfs *", 0, 0, (void*)0, 0};
+              static swig_type_info _swigt__p_storage__BtrfsSubvolume = {
+         "_p_storage__BtrfsSubvolume", "storage::BtrfsSubvolume *|std::vector< storage::BtrfsSubvolume * >::value_type|std::vector< storage::BtrfsSubvolume const * >::value_type", 0, 0, (void*)0, 0};
+              static swig_type_info _swigt__p_storage__BtrfsSubvolumeNotFoundByPath = {
+         "_p_storage__BtrfsSubvolumeNotFoundByPath", "storage::BtrfsSubvolumeNotFoundByPath *", 0, 0, (void*)0, 0};
+              static swig_type_info _swigt__p_storage__Callbacks = {
+         "_p_storage__Callbacks", "storage::Callbacks *", 0, 0, (void*)0, 0};
+              static swig_type_info _swigt__p_storage__CheckCallbacks = {
+         "_p_storage__CheckCallbacks", "storage::CheckCallbacks *", 0, 0, (void*)0, 0};
+              static swig_type_info _swigt__p_storage__CodeLocation = {
+         "_p_storage__CodeLocation", "storage::CodeLocation *", 0, 0, (void*)0, 0};
+              static swig_type_info _swigt__p_storage__CommitCallbacks = {
+         "_p_storage__CommitCallbacks", "storage::CommitCallbacks *", 0, 0, (void*)0, 0};
+              static swig_type_info _swigt__p_storage__CommitOptions = {
+         "_p_storage__CommitOptions", "storage::CommitOptions *", 0, 0, (void*)0, 0};
+              static swig_type_info _swigt__p_storage__CompoundAction = {
+         "_p_storage__CompoundAction", "storage::CompoundAction *|std::vector< storage::CompoundAction * >::value_type|std::vector< storage::CompoundAction const * >::value_type", 0, 0, (void*)0, 0};
+              static swig_type_info _swigt__p_storage__ContentInfo = {
+         "_p_storage__ContentInfo", "storage::ContentInfo *", 0, 0, (void*)0, 0};
+              static swig_type_info _swigt__p_storage__Dasd = {
+         "_p_storage__Dasd", "std::vector< storage::Dasd * >::value_type|std::vector< storage::Dasd const * >::value_type|storage::Dasd *", 0, 0, (void*)0, 0};
+              static swig_type_info _swigt__p_storage__DasdPt = {
+         "_p_storage__DasdPt", "storage::DasdPt *", 0, 0, (void*)0, 0};
+              static swig_type_info _swigt__p_storage__DeactivateStatus = {
+         "_p_storage__DeactivateStatus", "storage::DeactivateStatus *", 0, 0, (void*)0, 0};
+              static swig_type_info _swigt__p_storage__Device = {
+         "_p_storage__Device", "std::vector< storage::Device * >::value_type|std::vector< storage::Device const * >::value_type|storage::Device *", 0, 0, (void*)0, 0};
+              static swig_type_info _swigt__p_storage__DeviceHasWrongType = {
+         "_p_storage__DeviceHasWrongType", "storage::DeviceHasWrongType *", 0, 0, (void*)0, 0};
+              static swig_type_info _swigt__p_storage__DeviceNotFound = {
+         "_p_storage__DeviceNotFound", "storage::DeviceNotFound *", 0, 0, (void*)0, 0};
+              static swig_type_info _swigt__p_storage__DeviceNotFoundByName = {
+         "_p_storage__DeviceNotFoundByName", "storage::DeviceNotFoundByName *", 0, 0, (void*)0, 0};
+              static swig_type_info _swigt__p_storage__DeviceNotFoundBySid = {
+         "_p_storage__DeviceNotFoundBySid", "storage::DeviceNotFoundBySid *", 0, 0, (void*)0, 0};
+              static swig_type_info _swigt__p_storage__DeviceNotFoundByUuid = {
+         "_p_storage__DeviceNotFoundByUuid", "storage::DeviceNotFoundByUuid *", 0, 0, (void*)0, 0};
+              static swig_type_info _swigt__p_storage__Devicegraph = {
+         "_p_storage__Devicegraph", "storage::Devicegraph *", 0, 0, (void*)0, 0};
+              static swig_type_info _swigt__p_storage__DifferentBlockSizes = {
+         "_p_storage__DifferentBlockSizes", "storage::DifferentBlockSizes *", 0, 0, (void*)0, 0};
+              static swig_type_info _swigt__p_storage__Disk = {
+         "_p_storage__Disk", "std::vector< storage::Disk * >::value_type|std::vector< storage::Disk const * >::value_type|storage::Disk *", 0, 0, (void*)0, 0};
+              static swig_type_info _swigt__p_storage__DmRaid = {
+         "_p_storage__DmRaid", "std::vector< storage::DmRaid * >::value_type|std::vector< storage::DmRaid const * >::value_type|storage::DmRaid *", 0, 0, (void*)0, 0};
+              static swig_type_info _swigt__p_storage__Encryption = {
+         "_p_storage__Encryption", "std::vector< storage::Encryption const * >::value_type|std::vector< storage::Encryption * >::value_type|storage::Encryption *", 0, 0, (void*)0, 0};
+              static swig_type_info _swigt__p_storage__Environment = {
+         "_p_storage__Environment", "storage::Environment *", 0, 0, (void*)0, 0};
+              static swig_type_info _swigt__p_storage__Exception = {
+         "_p_storage__Exception", "storage::Exception *", 0, 0, (void*)0, 0};
+              static swig_type_info _swigt__p_storage__Exfat = {
+         "_p_storage__Exfat", "storage::Exfat *", 0, 0, (void*)0, 0};
+              static swig_type_info _swigt__p_storage__Ext = {
+         "_p_storage__Ext", "storage::Ext *", 0, 0, (void*)0, 0};
+              static swig_type_info _swigt__p_storage__Ext2 = {
+         "_p_storage__Ext2", "storage::Ext2 *", 0, 0, (void*)0, 0};
+              static swig_type_info _swigt__p_storage__Ext3 = {
+         "_p_storage__Ext3", "storage::Ext3 *", 0, 0, (void*)0, 0};
+              static swig_type_info _swigt__p_storage__Ext4 = {
+         "_p_storage__Ext4", "storage::Ext4 *", 0, 0, (void*)0, 0};
+              static swig_type_info _swigt__p_storage__F2fs = {
+         "_p_storage__F2fs", "storage::F2fs *", 0, 0, (void*)0, 0};
+              static swig_type_info _swigt__p_storage__Filesystem = {
+         "_p_storage__Filesystem", "std::vector< storage::Filesystem const * >::value_type|std::vector< storage::Filesystem * >::value_type|storage::Filesystem *", 0, 0, (void*)0, 0};
+              static swig_type_info _swigt__p_storage__FilesystemUser = {
+         "_p_storage__FilesystemUser", "storage::FilesystemUser *", 0, 0, (void*)0, 0};
+              static swig_type_info _swigt__p_storage__Gpt = {
+         "_p_storage__Gpt", "storage::Gpt *", 0, 0, (void*)0, 0};
+              static swig_type_info _swigt__p_storage__Holder = {
+         "_p_storage__Holder", "std::vector< storage::Holder * >::value_type|std::vector< storage::Holder const * >::value_type|storage::Holder *", 0, 0, (void*)0, 0};
+              static swig_type_info _swigt__p_storage__HolderAlreadyExists = {
+         "_p_storage__HolderAlreadyExists", "storage::HolderAlreadyExists *", 0, 0, (void*)0, 0};
+              static swig_type_info _swigt__p_storage__HolderHasWrongType = {
+         "_p_storage__HolderHasWrongType", "storage::HolderHasWrongType *", 0, 0, (void*)0, 0};
+              static swig_type_info _swigt__p_storage__HolderNotFound = {
+         "_p_storage__HolderNotFound", "storage::HolderNotFound *", 0, 0, (void*)0, 0};
+              static swig_type_info _swigt__p_storage__HolderNotFoundBySids = {
+         "_p_storage__HolderNotFoundBySids", "storage::HolderNotFoundBySids *", 0, 0, (void*)0, 0};
+              static swig_type_info _swigt__p_storage__IOException = {
+         "_p_storage__IOException", "storage::IOException *", 0, 0, (void*)0, 0};
+              static swig_type_info _swigt__p_storage__ImplicitPt = {
+         "_p_storage__ImplicitPt", "storage::ImplicitPt *", 0, 0, (void*)0, 0};
+              static swig_type_info _swigt__p_storage__IndexOutOfRangeException = {
+         "_p_storage__IndexOutOfRangeException", "storage::IndexOutOfRangeException *", 0, 0, (void*)0, 0};
+              static swig_type_info _swigt__p_storage__InvalidBlockSize = {
+         "_p_storage__InvalidBlockSize", "storage::InvalidBlockSize *", 0, 0, (void*)0, 0};
+              static swig_type_info _swigt__p_storage__InvalidExtentSize = {
+         "_p_storage__InvalidExtentSize", "storage::InvalidExtentSize *", 0, 0, (void*)0, 0};
+              static swig_type_info _swigt__p_storage__InvalidMountPointPath = {
+         "_p_storage__InvalidMountPointPath", "storage::InvalidMountPointPath *", 0, 0, (void*)0, 0};
+              static swig_type_info _swigt__p_storage__Iso9660 = {
+         "_p_storage__Iso9660", "storage::Iso9660 *", 0, 0, (void*)0, 0};
+              static swig_type_info _swigt__p_storage__Jfs = {
+         "_p_storage__Jfs", "storage::Jfs *", 0, 0, (void*)0, 0};
+              static swig_type_info _swigt__p_storage__LockException = {
+         "_p_storage__LockException", "storage::LockException *", 0, 0, (void*)0, 0};
+              static swig_type_info _swigt__p_storage__Logger = {
+         "_p_storage__Logger", "storage::Logger *", 0, 0, (void*)0, 0};
+              static swig_type_info _swigt__p_storage__LogicException = {
+         "_p_storage__LogicException", "storage::LogicException *", 0, 0, (void*)0, 0};
+              static swig_type_info _swigt__p_storage__Luks = {
+         "_p_storage__Luks", "std::vector< storage::Luks * >::value_type|std::vector< storage::Luks const * >::value_type|storage::Luks *", 0, 0, (void*)0, 0};
+              static swig_type_info _swigt__p_storage__LvmLv = {
+         "_p_storage__LvmLv", "std::vector< storage::LvmLv * >::value_type|std::vector< storage::LvmLv const * >::value_type|storage::LvmLv *", 0, 0, (void*)0, 0};
+              static swig_type_info _swigt__p_storage__LvmLvNotFoundByLvName = {
+         "_p_storage__LvmLvNotFoundByLvName", "storage::LvmLvNotFoundByLvName *", 0, 0, (void*)0, 0};
+              static swig_type_info _swigt__p_storage__LvmPv = {
+         "_p_storage__LvmPv", "storage::LvmPv *|std::vector< storage::LvmPv * >::value_type|std::vector< storage::LvmPv const * >::value_type", 0, 0, (void*)0, 0};
+              static swig_type_info _swigt__p_storage__LvmVg = {
+         "_p_storage__LvmVg", "std::vector< storage::LvmVg * >::value_type|std::vector< storage::LvmVg const * >::value_type|storage::LvmVg *", 0, 0, (void*)0, 0};
+              static swig_type_info _swigt__p_storage__LvmVgNotFoundByVgName = {
+         "_p_storage__LvmVgNotFoundByVgName", "storage::LvmVgNotFoundByVgName *", 0, 0, (void*)0, 0};
+              static swig_type_info _swigt__p_storage__Md = {
+         "_p_storage__Md", "std::vector< storage::Md * >::value_type|std::vector< storage::Md const * >::value_type|storage::Md *", 0, 0, (void*)0, 0};
+              static swig_type_info _swigt__p_storage__MdContainer = {
+         "_p_storage__MdContainer", "std::vector< storage::MdContainer const * >::value_type|std::vector< storage::MdContainer * >::value_type|storage::MdContainer *", 0, 0, (void*)0, 0};
+              static swig_type_info _swigt__p_storage__MdMember = {
+         "_p_storage__MdMember", "storage::MdMember *|std::vector< storage::MdMember * >::value_type|std::vector< storage::MdMember const * >::value_type", 0, 0, (void*)0, 0};
+              static swig_type_info _swigt__p_storage__MdSubdevice = {
+         "_p_storage__MdSubdevice", "storage::MdSubdevice *", 0, 0, (void*)0, 0};
+              static swig_type_info _swigt__p_storage__MdUser = {
+         "_p_storage__MdUser", "storage::MdUser *", 0, 0, (void*)0, 0};
+              static swig_type_info _swigt__p_storage__MountPoint = {
+         "_p_storage__MountPoint", "std::vector< storage::MountPoint const * >::value_type|std::vector< storage::MountPoint * >::value_type|storage::MountPoint *", 0, 0, (void*)0, 0};
+              static swig_type_info _swigt__p_storage__Mountable = {
+         "_p_storage__Mountable", "storage::Mountable *|std::vector< storage::Mountable * >::value_type|std::vector< storage::Mountable const * >::value_type", 0, 0, (void*)0, 0};
+              static swig_type_info _swigt__p_storage__Msdos = {
+         "_p_storage__Msdos", "storage::Msdos *", 0, 0, (void*)0, 0};
+              static swig_type_info _swigt__p_storage__Multipath = {
+         "_p_storage__Multipath", "std::vector< storage::Multipath * >::value_type|storage::Multipath *|std::vector< storage::Multipath const * >::value_type", 0, 0, (void*)0, 0};
+              static swig_type_info _swigt__p_storage__Nfs = {
+         "_p_storage__Nfs", "std::vector< storage::Nfs * >::value_type|std::vector< storage::Nfs const * >::value_type|storage::Nfs *", 0, 0, (void*)0, 0};
+              static swig_type_info _swigt__p_storage__NfsNotFoundByServerAndPath = {
+         "_p_storage__NfsNotFoundByServerAndPath", "storage::NfsNotFoundByServerAndPath *", 0, 0, (void*)0, 0};
+              static swig_type_info _swigt__p_storage__NoIntersection = {
+         "_p_storage__NoIntersection", "storage::NoIntersection *", 0, 0, (void*)0, 0};
+              static swig_type_info _swigt__p_storage__NotInside = {
+         "_p_storage__NotInside", "storage::NotInside *", 0, 0, (void*)0, 0};
+              static swig_type_info _swigt__p_storage__Ntfs = {
+         "_p_storage__Ntfs", "storage::Ntfs *|std::vector< storage::Ntfs * >::value_type|std::vector< storage::Ntfs const * >::value_type", 0, 0, (void*)0, 0};
+              static swig_type_info _swigt__p_storage__NullPointerException = {
+         "_p_storage__NullPointerException", "storage::NullPointerException *", 0, 0, (void*)0, 0};
+              static swig_type_info _swigt__p_storage__OutOfMemoryException = {
+         "_p_storage__OutOfMemoryException", "storage::OutOfMemoryException *", 0, 0, (void*)0, 0};
+              static swig_type_info _swigt__p_storage__OverflowException = {
+         "_p_storage__OverflowException", "storage::OverflowException *", 0, 0, (void*)0, 0};
+              static swig_type_info _swigt__p_storage__ParseException = {
+         "_p_storage__ParseException", "storage::ParseException *", 0, 0, (void*)0, 0};
+              static swig_type_info _swigt__p_storage__Partition = {
+         "_p_storage__Partition", "storage::Partition *|std::vector< storage::Partition * >::value_type|std::vector< storage::Partition const * >::value_type", 0, 0, (void*)0, 0};
+              static swig_type_info _swigt__p_storage__PartitionSlot = {
+         "_p_storage__PartitionSlot", "storage::PartitionSlot *|std::vector< storage::PartitionSlot >::value_type *", 0, 0, (void*)0, 0};
+              static swig_type_info _swigt__p_storage__PartitionTable = {
+         "_p_storage__PartitionTable", "storage::PartitionTable *", 0, 0, (void*)0, 0};
+              static swig_type_info _swigt__p_storage__Partitionable = {
+         "_p_storage__Partitionable", "storage::Partitionable *|std::vector< storage::Partitionable const * >::value_type|std::vector< storage::Partitionable * >::value_type", 0, 0, (void*)0, 0};
+              static swig_type_info _swigt__p_storage__ProbeCallbacks = {
+         "_p_storage__ProbeCallbacks", "storage::ProbeCallbacks *", 0, 0, (void*)0, 0};
+              static swig_type_info _swigt__p_storage__Region = {
+         "_p_storage__Region", "storage::Region *", 0, 0, (void*)0, 0};
+              static swig_type_info _swigt__p_storage__Reiserfs = {
+         "_p_storage__Reiserfs", "storage::Reiserfs *", 0, 0, (void*)0, 0};
+              static swig_type_info _swigt__p_storage__RemoteCallbacks = {
+         "_p_storage__RemoteCallbacks", "storage::RemoteCallbacks *", 0, 0, (void*)0, 0};
+              static swig_type_info _swigt__p_storage__RemoteCommand = {
+         "_p_storage__RemoteCommand", "storage::RemoteCommand *", 0, 0, (void*)0, 0};
+              static swig_type_info _swigt__p_storage__RemoteFile = {
+         "_p_storage__RemoteFile", "storage::RemoteFile *", 0, 0, (void*)0, 0};
+              static swig_type_info _swigt__p_storage__ResizeInfo = {
+         "_p_storage__ResizeInfo", "storage::ResizeInfo *", 0, 0, (void*)0, 0};
+              static swig_type_info _swigt__p_storage__Silencer = {
+         "_p_storage__Silencer", "storage::Silencer *", 0, 0, (void*)0, 0};
+              static swig_type_info _swigt__p_storage__SimpleEtcCrypttabEntry = {
+         "_p_storage__SimpleEtcCrypttabEntry", "storage::SimpleEtcCrypttabEntry *|std::vector< storage::SimpleEtcCrypttabEntry >::value_type *", 0, 0, (void*)0, 0};
+              static swig_type_info _swigt__p_storage__SimpleEtcFstabEntry = {
+         "_p_storage__SimpleEtcFstabEntry", "std::vector< storage::SimpleEtcFstabEntry >::value_type *|storage::SimpleEtcFstabEntry *", 0, 0, (void*)0, 0};
+              static swig_type_info _swigt__p_storage__SpaceInfo = {
+         "_p_storage__SpaceInfo", "storage::SpaceInfo *", 0, 0, (void*)0, 0};
+              static swig_type_info _swigt__p_storage__Storage = {
+         "_p_storage__Storage", "storage::Storage *", 0, 0, (void*)0, 0};
+              static swig_type_info _swigt__p_storage__StrayBlkDevice = {
+         "_p_storage__StrayBlkDevice", "std::vector< storage::StrayBlkDevice * >::value_type|storage::StrayBlkDevice *|std::vector< storage::StrayBlkDevice const * >::value_type", 0, 0, (void*)0, 0};
+              static swig_type_info _swigt__p_storage__Subdevice = {
+         "_p_storage__Subdevice", "storage::Subdevice *", 0, 0, (void*)0, 0};
+              static swig_type_info _swigt__p_storage__Swap = {
+         "_p_storage__Swap", "std::vector< storage::Swap * >::value_type|std::vector< storage::Swap const * >::value_type|storage::Swap *", 0, 0, (void*)0, 0};
+              static swig_type_info _swigt__p_storage__Topology = {
+         "_p_storage__Topology", "storage::Topology *", 0, 0, (void*)0, 0};
+              static swig_type_info _swigt__p_storage__Udf = {
+         "_p_storage__Udf", "storage::Udf *", 0, 0, (void*)0, 0};
+              static swig_type_info _swigt__p_storage__UnsupportedException = {
+         "_p_storage__UnsupportedException", "storage::UnsupportedException *", 0, 0, (void*)0, 0};
+              static swig_type_info _swigt__p_storage__User = {
+         "_p_storage__User", "storage::User *", 0, 0, (void*)0, 0};
+              static swig_type_info _swigt__p_storage__Vfat = {
+         "_p_storage__Vfat", "storage::Vfat *", 0, 0, (void*)0, 0};
+              static swig_type_info _swigt__p_storage__WrongNumberOfChildren = {
+         "_p_storage__WrongNumberOfChildren", "storage::WrongNumberOfChildren *", 0, 0, (void*)0, 0};
+              static swig_type_info _swigt__p_storage__WrongNumberOfParents = {
+         "_p_storage__WrongNumberOfParents", "storage::WrongNumberOfParents *", 0, 0, (void*)0, 0};
+              static swig_type_info _swigt__p_storage__Xfs = {
+         "_p_storage__Xfs", "storage::Xfs *", 0, 0, (void*)0, 0};
+              static swig_type_info _swigt__p_swig__SwigPyIterator = {
+         "_p_swig__SwigPyIterator", "swig::SwigPyIterator *", 0, 0, (void*)0, 0};
+              static swig_type_info _swigt__p_unsigned_char = {
+         "_p_unsigned_char", "unsigned char *|uint_least8_t *|uint_fast8_t *|uint8_t *", 0, 0, (void*)0, 0};
+              static swig_type_info _swigt__p_unsigned_int = {
+         "_p_unsigned_int", "uintptr_t *|uint_least32_t *|uint_fast32_t *|uint32_t *|unsigned int *|storage::sid_t *|uint_fast16_t *", 0, 0, (void*)0, 0};
+              static swig_type_info _swigt__p_unsigned_long_long = {
+         "_p_unsigned_long_long", "uint_least64_t *|uint_fast64_t *|uint64_t *|unsigned long long *|uintmax_t *", 0, 0, (void*)0, 0};
+              static swig_type_info _swigt__p_unsigned_short = {
+         "_p_unsigned_short", "unsigned short *|uint_least16_t *|uint16_t *", 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 _swigt__p_xmlNode = {
+         "_p_xmlNode", "xmlNode *", 0, 0, (void*)0, 0};
+              static swig_type_info *swig_type_initial[] = {
+            &_swigt__p_allocator_type,   &_swigt__p_char,   &_swigt__p_const_reference,   &_swigt__p_difference_type,   &_swigt__p_first_type,   &_swigt__p_int,   &_swigt__p_key_type,   &_swigt__p_long_long,   &_swigt__p_mapped_type,   &_swigt__p_p_PyObject,   &_swigt__p_reference,   &_swigt__p_second_type,   &_swigt__p_short,   &_swigt__p_signed_char,   &_swigt__p_size_type,   &_swigt__p_std__allocatorT_std__pairT_std__string_const_std__string_t_t,   &_swigt__p_std__allocatorT_std__string_t,   &_swigt__p_std__allocatorT_storage__BcacheCset_const_p_t,   &_swigt__p_std__allocatorT_storage__BcacheCset_p_t,   &_swigt__p_std__allocatorT_storage__Bcache_const_p_t,   &_swigt__p_std__allocatorT_storage__Bcache_p_t,   &_swigt__p_std__allocatorT_storage__BlkDevice_const_p_t,   &_swigt__p_std__allocatorT_storage__BlkDevice_p_t,   &_swigt__p_std__allocatorT_storage__BlkFilesystem_const_p_t,   &_swigt__p_std__allocatorT_storage__BlkFilesystem_p_t,   &_swigt__p_std__allocatorT_storage__BtrfsSubvolume_const_p_t,   &_swigt__p_std__allocatorT_storage__BtrfsSubvolume_p_t,   &_swigt__p_std__allocatorT_storage__CompoundAction_const_p_t,   &_swigt__p_std__allocatorT_storage__CompoundAction_p_t,   &_swigt__p_std__allocatorT_storage__Dasd_const_p_t,   &_swigt__p_std__allocatorT_storage__Dasd_p_t,   &_swigt__p_std__allocatorT_storage__Device_const_p_t,   &_swigt__p_std__allocatorT_storage__Device_p_t,   &_swigt__p_std__allocatorT_storage__Disk_const_p_t,   &_swigt__p_std__allocatorT_storage__Disk_p_t,   &_swigt__p_std__allocatorT_storage__DmRaid_const_p_t,   &_swigt__p_std__allocatorT_storage__DmRaid_p_t,   &_swigt__p_std__allocatorT_storage__Encryption_const_p_t,   &_swigt__p_std__allocatorT_storage__Encryption_p_t,   &_swigt__p_std__allocatorT_storage__Filesystem_const_p_t,   &_swigt__p_std__allocatorT_storage__Filesystem_p_t,   &_swigt__p_std__allocatorT_storage__Holder_const_p_t,   &_swigt__p_std__allocatorT_storage__Holder_p_t,   &_swigt__p_std__allocatorT_storage__Luks_const_p_t,   &_swigt__p_std__allocatorT_storage__Luks_p_t,   &_swigt__p_std__allocatorT_storage__LvmLv_const_p_t,   &_swigt__p_std__allocatorT_storage__LvmLv_p_t,   &_swigt__p_std__allocatorT_storage__LvmPv_const_p_t,   &_swigt__p_std__allocatorT_storage__LvmPv_p_t,   &_swigt__p_std__allocatorT_storage__LvmVg_const_p_t,   &_swigt__p_std__allocatorT_storage__LvmVg_p_t,   &_swigt__p_std__allocatorT_storage__MdContainer_const_p_t,   &_swigt__p_std__allocatorT_storage__MdContainer_p_t,   &_swigt__p_std__allocatorT_storage__MdMember_const_p_t,   &_swigt__p_std__allocatorT_storage__MdMember_p_t,   &_swigt__p_std__allocatorT_storage__MdParity_t,   &_swigt__p_std__allocatorT_storage__Md_const_p_t,   &_swigt__p_std__allocatorT_storage__Md_p_t,   &_swigt__p_std__allocatorT_storage__MountByType_t,   &_swigt__p_std__allocatorT_storage__MountPoint_const_p_t,   &_swigt__p_std__allocatorT_storage__MountPoint_p_t,   &_swigt__p_std__allocatorT_storage__Mountable_const_p_t,   &_swigt__p_std__allocatorT_storage__Mountable_p_t,   &_swigt__p_std__allocatorT_storage__Multipath_const_p_t,   &_swigt__p_std__allocatorT_storage__Multipath_p_t,   &_swigt__p_std__allocatorT_storage__Nfs_const_p_t,   &_swigt__p_std__allocatorT_storage__Nfs_p_t,   &_swigt__p_std__allocatorT_storage__Ntfs_const_p_t,   &_swigt__p_std__allocatorT_storage__Ntfs_p_t,   &_swigt__p_std__allocatorT_storage__PartitionSlot_t,   &_swigt__p_std__allocatorT_storage__Partition_const_p_t,   &_swigt__p_std__allocatorT_storage__Partition_p_t,   &_swigt__p_std__allocatorT_storage__Partitionable_const_p_t,   &_swigt__p_std__allocatorT_storage__Partitionable_p_t,   &_swigt__p_std__allocatorT_storage__PtType_t,   &_swigt__p_std__allocatorT_storage__SimpleEtcCrypttabEntry_t,   &_swigt__p_std__allocatorT_storage__SimpleEtcFstabEntry_t,   &_swigt__p_std__allocatorT_storage__StrayBlkDevice_const_p_t,   &_swigt__p_std__allocatorT_storage__StrayBlkDevice_p_t,   &_swigt__p_std__allocatorT_storage__Swap_const_p_t,   &_swigt__p_std__allocatorT_storage__Swap_p_t,   &_swigt__p_std__exception,   &_swigt__p_std__invalid_argument,   &_swigt__p_std__lessT_std__string_t,   &_swigt__p_std__mapT_std__string_std__string_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_std__string_t_t_t,   &_swigt__p_std__ostream,   &_swigt__p_std__pairT_bool_std__string_t,   &_swigt__p_std__vectorT_std__string_std__allocatorT_std__string_t_t,   &_swigt__p_std__vectorT_storage__Action__Base_const_p_std__allocatorT_storage__Action__Base_const_p_t_t,   &_swigt__p_std__vectorT_storage__BcacheCset_const_p_std__allocatorT_storage__BcacheCset_const_p_t_t,   &_swigt__p_std__vectorT_storage__BcacheCset_p_std__allocatorT_storage__BcacheCset_p_t_t,   &_swigt__p_std__vectorT_storage__Bcache_const_p_std__allocatorT_storage__Bcache_const_p_t_t,   &_swigt__p_std__vectorT_storage__Bcache_p_std__allocatorT_storage__Bcache_p_t_t,   &_swigt__p_std__vectorT_storage__BlkDevice_const_p_std__allocatorT_storage__BlkDevice_const_p_t_t,   &_swigt__p_std__vectorT_storage__BlkDevice_p_std__allocatorT_storage__BlkDevice_p_t_t,   &_swigt__p_std__vectorT_storage__BlkFilesystem_const_p_std__allocatorT_storage__BlkFilesystem_const_p_t_t,   &_swigt__p_std__vectorT_storage__BlkFilesystem_p_std__allocatorT_storage__BlkFilesystem_p_t_t,   &_swigt__p_std__vectorT_storage__BtrfsSubvolume_const_p_std__allocatorT_storage__BtrfsSubvolume_const_p_t_t,   &_swigt__p_std__vectorT_storage__BtrfsSubvolume_p_std__allocatorT_storage__BtrfsSubvolume_p_t_t,   &_swigt__p_std__vectorT_storage__CompoundAction_const_p_std__allocatorT_storage__CompoundAction_const_p_t_t,   &_swigt__p_std__vectorT_storage__CompoundAction_p_std__allocatorT_storage__CompoundAction_p_t_t,   &_swigt__p_std__vectorT_storage__Dasd_const_p_std__allocatorT_storage__Dasd_const_p_t_t,   &_swigt__p_std__vectorT_storage__Dasd_p_std__allocatorT_storage__Dasd_p_t_t,   &_swigt__p_std__vectorT_storage__Device_const_p_std__allocatorT_storage__Device_const_p_t_t,   &_swigt__p_std__vectorT_storage__Device_p_std__allocatorT_storage__Device_p_t_t,   &_swigt__p_std__vectorT_storage__Disk_const_p_std__allocatorT_storage__Disk_const_p_t_t,   &_swigt__p_std__vectorT_storage__Disk_p_std__allocatorT_storage__Disk_p_t_t,   &_swigt__p_std__vectorT_storage__DmRaid_const_p_std__allocatorT_storage__DmRaid_const_p_t_t,   &_swigt__p_std__vectorT_storage__DmRaid_p_std__allocatorT_storage__DmRaid_p_t_t,   &_swigt__p_std__vectorT_storage__Encryption_const_p_std__allocatorT_storage__Encryption_const_p_t_t,   &_swigt__p_std__vectorT_storage__Encryption_p_std__allocatorT_storage__Encryption_p_t_t,   &_swigt__p_std__vectorT_storage__Filesystem_const_p_std__allocatorT_storage__Filesystem_const_p_t_t,   &_swigt__p_std__vectorT_storage__Filesystem_p_std__allocatorT_storage__Filesystem_p_t_t,   &_swigt__p_std__vectorT_storage__Gpt_const_p_std__allocatorT_storage__Gpt_const_p_t_t,   &_swigt__p_std__vectorT_storage__Gpt_p_std__allocatorT_storage__Gpt_p_t_t,   &_swigt__p_std__vectorT_storage__Holder_const_p_std__allocatorT_storage__Holder_const_p_t_t,   &_swigt__p_std__vectorT_storage__Holder_p_std__allocatorT_storage__Holder_p_t_t,   &_swigt__p_std__vectorT_storage__Luks_const_p_std__allocatorT_storage__Luks_const_p_t_t,   &_swigt__p_std__vectorT_storage__Luks_p_std__allocatorT_storage__Luks_p_t_t,   &_swigt__p_std__vectorT_storage__LvmLv_const_p_std__allocatorT_storage__LvmLv_const_p_t_t,   &_swigt__p_std__vectorT_storage__LvmLv_p_std__allocatorT_storage__LvmLv_p_t_t,   &_swigt__p_std__vectorT_storage__LvmPv_const_p_std__allocatorT_storage__LvmPv_const_p_t_t,   &_swigt__p_std__vectorT_storage__LvmPv_p_std__allocatorT_storage__LvmPv_p_t_t,   &_swigt__p_std__vectorT_storage__LvmVg_const_p_std__allocatorT_storage__LvmVg_const_p_t_t,   &_swigt__p_std__vectorT_storage__LvmVg_p_std__allocatorT_storage__LvmVg_p_t_t,   &_swigt__p_std__vectorT_storage__MdContainer_const_p_std__allocatorT_storage__MdContainer_const_p_t_t,   &_swigt__p_std__vectorT_storage__MdContainer_p_std__allocatorT_storage__MdContainer_p_t_t,   &_swigt__p_std__vectorT_storage__MdMember_const_p_std__allocatorT_storage__MdMember_const_p_t_t,   &_swigt__p_std__vectorT_storage__MdMember_p_std__allocatorT_storage__MdMember_p_t_t,   &_swigt__p_std__vectorT_storage__MdParity_std__allocatorT_storage__MdParity_t_t,   &_swigt__p_std__vectorT_storage__Md_const_p_std__allocatorT_storage__Md_const_p_t_t,   &_swigt__p_std__vectorT_storage__Md_p_std__allocatorT_storage__Md_p_t_t,   &_swigt__p_std__vectorT_storage__MountByType_std__allocatorT_storage__MountByType_t_t,   &_swigt__p_std__vectorT_storage__MountPoint_const_p_std__allocatorT_storage__MountPoint_const_p_t_t,   &_swigt__p_std__vectorT_storage__MountPoint_p_std__allocatorT_storage__MountPoint_p_t_t,   &_swigt__p_std__vectorT_storage__Mountable_const_p_std__allocatorT_storage__Mountable_const_p_t_t,   &_swigt__p_std__vectorT_storage__Mountable_p_std__allocatorT_storage__Mountable_p_t_t,   &_swigt__p_std__vectorT_storage__Multipath_const_p_std__allocatorT_storage__Multipath_const_p_t_t,   &_swigt__p_std__vectorT_storage__Multipath_p_std__allocatorT_storage__Multipath_p_t_t,   &_swigt__p_std__vectorT_storage__Nfs_const_p_std__allocatorT_storage__Nfs_const_p_t_t,   &_swigt__p_std__vectorT_storage__Nfs_p_std__allocatorT_storage__Nfs_p_t_t,   &_swigt__p_std__vectorT_storage__Ntfs_const_p_std__allocatorT_storage__Ntfs_const_p_t_t,   &_swigt__p_std__vectorT_storage__Ntfs_p_std__allocatorT_storage__Ntfs_p_t_t,   &_swigt__p_std__vectorT_storage__PartitionSlot_std__allocatorT_storage__PartitionSlot_t_t,   &_swigt__p_std__vectorT_storage__Partition_const_p_std__allocatorT_storage__Partition_const_p_t_t,   &_swigt__p_std__vectorT_storage__Partition_p_std__allocatorT_storage__Partition_p_t_t,   &_swigt__p_std__vectorT_storage__Partitionable_const_p_std__allocatorT_storage__Partitionable_const_p_t_t,   &_swigt__p_std__vectorT_storage__Partitionable_p_std__allocatorT_storage__Partitionable_p_t_t,   &_swigt__p_std__vectorT_storage__PtType_std__allocatorT_storage__PtType_t_t,   &_swigt__p_std__vectorT_storage__Region_std__allocatorT_storage__Region_t_t,   &_swigt__p_std__vectorT_storage__SimpleEtcCrypttabEntry_std__allocatorT_storage__SimpleEtcCrypttabEntry_t_t,   &_swigt__p_std__vectorT_storage__SimpleEtcFstabEntry_std__allocatorT_storage__SimpleEtcFstabEntry_t_t,   &_swigt__p_std__vectorT_storage__StrayBlkDevice_const_p_std__allocatorT_storage__StrayBlkDevice_const_p_t_t,   &_swigt__p_std__vectorT_storage__StrayBlkDevice_p_std__allocatorT_storage__StrayBlkDevice_p_t_t,   &_swigt__p_std__vectorT_storage__Swap_const_p_std__allocatorT_storage__Swap_const_p_t_t,   &_swigt__p_std__vectorT_storage__Swap_p_std__allocatorT_storage__Swap_p_t_t,   &_swigt__p_storage__Aborted,   &_swigt__p_storage__Actiongraph,   &_swigt__p_storage__ActivateCallbacks,   &_swigt__p_storage__AlignError,   &_swigt__p_storage__Alignment,   &_swigt__p_storage__Arch,   &_swigt__p_storage__Bcache,   &_swigt__p_storage__BcacheCset,   &_swigt__p_storage__BlkDevice,   &_swigt__p_storage__BlkFilesystem,   &_swigt__p_storage__Btrfs,   &_swigt__p_storage__BtrfsSubvolume,   &_swigt__p_storage__BtrfsSubvolumeNotFoundByPath,   &_swigt__p_storage__Callbacks,   &_swigt__p_storage__CheckCallbacks,   &_swigt__p_storage__CodeLocation,   &_swigt__p_storage__CommitCallbacks,   &_swigt__p_storage__CommitOptions,   &_swigt__p_storage__CompoundAction,   &_swigt__p_storage__ContentInfo,   &_swigt__p_storage__Dasd,   &_swigt__p_storage__DasdPt,   &_swigt__p_storage__DeactivateStatus,   &_swigt__p_storage__Device,   &_swigt__p_storage__DeviceHasWrongType,   &_swigt__p_storage__DeviceNotFound,   &_swigt__p_storage__DeviceNotFoundByName,   &_swigt__p_storage__DeviceNotFoundBySid,   &_swigt__p_storage__DeviceNotFoundByUuid,   &_swigt__p_storage__Devicegraph,   &_swigt__p_storage__DifferentBlockSizes,   &_swigt__p_storage__Disk,   &_swigt__p_storage__DmRaid,   &_swigt__p_storage__Encryption,   &_swigt__p_storage__Environment,   &_swigt__p_storage__Exception,   &_swigt__p_storage__Exfat,   &_swigt__p_storage__Ext,   &_swigt__p_storage__Ext2,   &_swigt__p_storage__Ext3,   &_swigt__p_storage__Ext4,   &_swigt__p_storage__F2fs,   &_swigt__p_storage__Filesystem,   &_swigt__p_storage__FilesystemUser,   &_swigt__p_storage__Gpt,   &_swigt__p_storage__Holder,   &_swigt__p_storage__HolderAlreadyExists,   &_swigt__p_storage__HolderHasWrongType,   &_swigt__p_storage__HolderNotFound,   &_swigt__p_storage__HolderNotFoundBySids,   &_swigt__p_storage__IOException,   &_swigt__p_storage__ImplicitPt,   &_swigt__p_storage__IndexOutOfRangeException,   &_swigt__p_storage__InvalidBlockSize,   &_swigt__p_storage__InvalidExtentSize,   &_swigt__p_storage__InvalidMountPointPath,   &_swigt__p_storage__Iso9660,   &_swigt__p_storage__Jfs,   &_swigt__p_storage__LockException,   &_swigt__p_storage__Logger,   &_swigt__p_storage__LogicException,   &_swigt__p_storage__Luks,   &_swigt__p_storage__LvmLv,   &_swigt__p_storage__LvmLvNotFoundByLvName,   &_swigt__p_storage__LvmPv,   &_swigt__p_storage__LvmVg,   &_swigt__p_storage__LvmVgNotFoundByVgName,   &_swigt__p_storage__Md,   &_swigt__p_storage__MdContainer,   &_swigt__p_storage__MdMember,   &_swigt__p_storage__MdSubdevice,   &_swigt__p_storage__MdUser,   &_swigt__p_storage__MountPoint,   &_swigt__p_storage__Mountable,   &_swigt__p_storage__Msdos,   &_swigt__p_storage__Multipath,   &_swigt__p_storage__Nfs,   &_swigt__p_storage__NfsNotFoundByServerAndPath,   &_swigt__p_storage__NoIntersection,   &_swigt__p_storage__NotInside,   &_swigt__p_storage__Ntfs,   &_swigt__p_storage__NullPointerException,   &_swigt__p_storage__OutOfMemoryException,   &_swigt__p_storage__OverflowException,   &_swigt__p_storage__ParseException,   &_swigt__p_storage__Partition,   &_swigt__p_storage__PartitionSlot,   &_swigt__p_storage__PartitionTable,   &_swigt__p_storage__Partitionable,   &_swigt__p_storage__ProbeCallbacks,   &_swigt__p_storage__Region,   &_swigt__p_storage__Reiserfs,   &_swigt__p_storage__RemoteCallbacks,   &_swigt__p_storage__RemoteCommand,   &_swigt__p_storage__RemoteFile,   &_swigt__p_storage__ResizeInfo,   &_swigt__p_storage__Silencer,   &_swigt__p_storage__SimpleEtcCrypttabEntry,   &_swigt__p_storage__SimpleEtcFstabEntry,   &_swigt__p_storage__SpaceInfo,   &_swigt__p_storage__Storage,   &_swigt__p_storage__StrayBlkDevice,   &_swigt__p_storage__Subdevice,   &_swigt__p_storage__Swap,   &_swigt__p_storage__Topology,   &_swigt__p_storage__Udf,   &_swigt__p_storage__UnsupportedException,   &_swigt__p_storage__User,   &_swigt__p_storage__Vfat,   &_swigt__p_storage__WrongNumberOfChildren,   &_swigt__p_storage__WrongNumberOfParents,   &_swigt__p_storage__Xfs,   &_swigt__p_swig__SwigPyIterator,   &_swigt__p_unsigned_char,   &_swigt__p_unsigned_int,   &_swigt__p_unsigned_long_long,   &_swigt__p_unsigned_short,   &_swigt__p_value_type,   &_swigt__p_xmlNode, };
+              static swig_const_info swig_const_table[] = {
+         };
+                static __attribute__ ((__unused__)) void   SWIG_Python_FixMethods(PyMethodDef *methods,     swig_const_info *const_table,     swig_type_info **types,     swig_type_info **types_initial) ;
+              }
+                   extern "C" __attribute__ ((visibility("default"))) PyObject* PyInit__storage(void) {
+                SWIG_Python_FixMethods(SwigMethods, swig_const_table, swig_types, swig_type_initial);
+              }