From patchwork Tue Jan 15 06:59:21 2019 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Prathamesh Kulkarni X-Patchwork-Id: 155630 Delivered-To: patch@linaro.org Received: by 2002:a02:48:0:0:0:0:0 with SMTP id 69csp4548504jaa; Mon, 14 Jan 2019 23:00:06 -0800 (PST) X-Google-Smtp-Source: ALg8bN4lNqQaoKPslSNDrhLobYbc3898S3LvRMQiYgPpWi3a8I7YeRc1exx10Gc/g969P+Gh4/Wc X-Received: by 2002:a17:902:6f09:: with SMTP id w9mr2595744plk.309.1547535606467; Mon, 14 Jan 2019 23:00:06 -0800 (PST) ARC-Seal: i=1; a=rsa-sha256; t=1547535606; cv=none; d=google.com; s=arc-20160816; b=YJ16o3fK6Y8QAahBqr8vaQMdr+ktwsglWavybC7a1n/w8D04UbeZdmY3HLQeH9BEOh d1woGkJr6AWgDYXId4uWL23kGDnQuAAp50vpD4oDW5hzV56QN4M37oHvYZseelx6aEiX e71tP3dQCfqJIu2spJyYPUZJeYtWeAM2NofBdqVKCiP/A3V7fwdT1gESx3i923RiCQiv vE9ssiLHm0Gu+kEywCjdU3g4B9NVyztYXDG+vjViFp7xNR8Q4SE8+P4Eiy4D3cA6qo2h CyUkq/q/uBheaki7un/L/ClEU5A3QxgeBexsoET4PfaIiKJ7/NBpRvkGbqJ0k/SOmKF3 n9aw== ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=google.com; s=arc-20160816; h=to:subject:message-id:date:from:mime-version:dkim-signature :delivered-to:sender:list-help:list-post:list-archive :list-unsubscribe:list-id:precedence:mailing-list:dkim-signature :domainkey-signature; bh=Hgr35DR2tB5mEHGSwif7GDrygk/Dql4nflboJyHLrWE=; b=VTpAq4M30d9khI4AjkIUHWif4ePiyP8MRMheJ0ZaMJBolqJKEiBeZdp0DdrEdV2Rn4 ByiJB/PNul7tyWGUW3sA88pTaAdyAnbX3fLJDMw8RC0kjZKi86keOpgBoKS0lYXshMV+ OoY+VIO8Vq+0sqkk96YwEtP3DX5qbJzw5FxC9u1bRE+KizRvyGAEpXXyeJYfEkNpdPjT h5tyFf7RKZUBqg8lmO61dbcc41aDXqKNirLsYdNLhZc44dcR58o1h1ATAfxn+Il0S76W i+zSwQ9/I96Rrihe34HPosWgYZADGTBCVUx+ocuGbkhNJC14XgID9CBFOLueY0wqj/UH Pbgg== ARC-Authentication-Results: i=1; mx.google.com; dkim=pass header.i=@gcc.gnu.org header.s=default header.b=nD2lwfPH; dkim=neutral (body hash did not verify) header.i=@linaro.org header.s=google header.b=RIMst37b; spf=pass (google.com: domain of gcc-patches-return-494048-patch=linaro.org@gcc.gnu.org designates 209.132.180.131 as permitted sender) smtp.mailfrom="gcc-patches-return-494048-patch=linaro.org@gcc.gnu.org"; dmarc=fail (p=NONE sp=NONE dis=NONE) header.from=linaro.org Return-Path: Received: from sourceware.org (server1.sourceware.org. [209.132.180.131]) by mx.google.com with ESMTPS id b7si2559821plb.234.2019.01.14.23.00.06 for (version=TLS1_2 cipher=ECDHE-RSA-AES128-GCM-SHA256 bits=128/128); Mon, 14 Jan 2019 23:00:06 -0800 (PST) Received-SPF: pass (google.com: domain of gcc-patches-return-494048-patch=linaro.org@gcc.gnu.org designates 209.132.180.131 as permitted sender) client-ip=209.132.180.131; Authentication-Results: mx.google.com; dkim=pass header.i=@gcc.gnu.org header.s=default header.b=nD2lwfPH; dkim=neutral (body hash did not verify) header.i=@linaro.org header.s=google header.b=RIMst37b; spf=pass (google.com: domain of gcc-patches-return-494048-patch=linaro.org@gcc.gnu.org designates 209.132.180.131 as permitted sender) smtp.mailfrom="gcc-patches-return-494048-patch=linaro.org@gcc.gnu.org"; dmarc=fail (p=NONE sp=NONE dis=NONE) header.from=linaro.org DomainKey-Signature: a=rsa-sha1; c=nofws; d=gcc.gnu.org; h=list-id :list-unsubscribe:list-archive:list-post:list-help:sender :mime-version:from:date:message-id:subject:to:content-type; q= dns; s=default; b=aNXy8b+LXhmBDxMUaqe0uK/I4xHvwecG7T1nJER4/7fmCF N1ABpi3eFNsQ6JKfldiU5WzTPjsLQ5C9Td7HIXkak+TJ8P1KknV2FpkgUsipT4xa oCI+nMFwHFxh/WTbtJjm2vokSOGDuiWZJ8NiGz1eGR7T5LmdConqNJRgiBo7Y= DKIM-Signature: v=1; a=rsa-sha1; c=relaxed; d=gcc.gnu.org; h=list-id :list-unsubscribe:list-archive:list-post:list-help:sender :mime-version:from:date:message-id:subject:to:content-type; s= default; bh=2mIxZIrqsPMaJYCGvVEYg2tAI14=; b=nD2lwfPH9CsNSqoyo/pz OLUJF3/I7O4k1bgHJIvTmKxlf5+M4oDXc6JikC0jGD0uM/uHHD0Dtggbf2PUvFIZ jeCgB6NuUwK+OrO7CQhqOdAkThBkmuCEk3XUBHDelcNehwqkdLRfKV/HjLuAvBlb rw9ItXOdlGFSItN0ySvh77U= Received: (qmail 51259 invoked by alias); 15 Jan 2019 06:59:47 -0000 Mailing-List: contact gcc-patches-help@gcc.gnu.org; run by ezmlm Precedence: bulk List-Id: List-Unsubscribe: List-Archive: List-Post: List-Help: Sender: gcc-patches-owner@gcc.gnu.org Delivered-To: mailing list gcc-patches@gcc.gnu.org Received: (qmail 51248 invoked by uid 89); 15 Jan 2019 06:59:46 -0000 Authentication-Results: sourceware.org; auth=none X-Spam-SWARE-Status: No, score=-6.9 required=5.0 tests=BAYES_00, GIT_PATCH_3, RCVD_IN_DNSWL_NONE, SPF_PASS, TIME_LIMIT_EXCEEDED autolearn=unavailable version=3.3.2 spammy=sk:gcc-tes, logger, partition, boost X-HELO: mail-lf1-f49.google.com Received: from mail-lf1-f49.google.com (HELO mail-lf1-f49.google.com) (209.85.167.49) by sourceware.org (qpsmtpd/0.93/v0.84-503-g423c35a) with ESMTP; Tue, 15 Jan 2019 06:59:35 +0000 Received: by mail-lf1-f49.google.com with SMTP id c16so1180100lfj.8 for ; Mon, 14 Jan 2019 22:59:34 -0800 (PST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=linaro.org; s=google; h=mime-version:from:date:message-id:subject:to; bh=6+xxxRvNohRwuc4HBaA5pRSPzosETBbrA0Zz33MGSKE=; b=RIMst37bkw4j+Rf4u2qbcX5sYBLOD+PbjAyLOH0emwUPGU10uK8i1JV1BiuTEvPL8t HNDBjsHJTBON9Y0OFqZs99gN1S0Vr+NFPNonFXvs6PL8y1BbnN2kHh490QU7qxN5NAa8 a9EcWKhpW0QNFbOL6/wcNezpBCIq3vPK/hxUg= MIME-Version: 1.0 From: Prathamesh Kulkarni Date: Tue, 15 Jan 2019 12:29:21 +0530 Message-ID: Subject: PR88788 - Infinite loop in malloc_candidate_p_1 To: gcc Patches , Richard Biener X-IsSubscribed: yes 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 Prathamesh Kulkarni 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. 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 (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(result); + if (dobj) { + dcast = 1; + } + } + if (!dcast) { + const storage::Luks *dobj = dynamic_cast(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(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(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(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(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(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(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(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(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(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(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(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(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(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(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(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(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(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(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(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(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(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(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(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(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(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(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(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(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(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(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(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(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(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(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(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(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(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(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); + }