# This file was automatically generated by SWIG (http://www.swig.org).
# Version 3.0.8
#
# Do not make changes to this file unless you know what you are doing--modify
# the SWIG interface file instead.

from sys import version_info
if version_info >= (2, 6, 0):

    def swig_import_helper():
        from os.path import dirname
        import imp
        fp = None
        try:
            fp, pathname, description = imp.find_module(
                '_infomap', [dirname(__file__)])
        except ImportError:
            import _infomap
            return _infomap
        if fp is not None:
            try:
                _mod = imp.load_module('_infomap', fp, pathname, description)
            finally:
                fp.close()
            return _mod

    _infomap = swig_import_helper()
    del swig_import_helper
else:
    import _infomap
del version_info
try:
    _swig_property = property
except NameError:
    pass  # Python < 2.2 doesn't have 'property'.


def _swig_setattr_nondynamic(self, class_type, name, value, static=1):
    if (name == "thisown"):
        return self.this.own(value)
    if (name == "this"):
        if type(value).__name__ == 'SwigPyObject':
            self.__dict__[name] = value
            return
    method = class_type.__swig_setmethods__.get(name, None)
    if method:
        return method(self, value)
    if (not static):
        if _newclass:
            object.__setattr__(self, name, value)
        else:
            self.__dict__[name] = value
    else:
        raise AttributeError("You cannot add attributes to %s" % self)


def _swig_setattr(self, class_type, name, value):
    return _swig_setattr_nondynamic(self, class_type, name, value, 0)


def _swig_getattr_nondynamic(self, class_type, name, static=1):
    if (name == "thisown"):
        return self.this.own()
    method = class_type.__swig_getmethods__.get(name, None)
    if method:
        return method(self)
    if (not static):
        return object.__getattr__(self, name)
    else:
        raise AttributeError(name)


def _swig_getattr(self, class_type, name):
    return _swig_getattr_nondynamic(self, class_type, name, 0)


def _swig_repr(self):
    try:
        strthis = "proxy of " + self.this.__repr__()
    except Exception:
        strthis = ""
    return "<%s.%s; %s >" % (
        self.__class__.__module__,
        self.__class__.__name__,
        strthis,
    )


try:
    _object = object
    _newclass = 1
except AttributeError:

    class _object:
        pass

    _newclass = 0


class SwigPyIterator(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(
        self, SwigPyIterator, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, SwigPyIterator, name)

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined - class is abstract")

    __repr__ = _swig_repr
    __swig_destroy__ = _infomap.delete_SwigPyIterator
    __del__ = lambda self: None

    def value(self):
        return _infomap.SwigPyIterator_value(self)

    def incr(self, n=1):
        return _infomap.SwigPyIterator_incr(self, n)

    def decr(self, n=1):
        return _infomap.SwigPyIterator_decr(self, n)

    def distance(self, x):
        return _infomap.SwigPyIterator_distance(self, x)

    def equal(self, x):
        return _infomap.SwigPyIterator_equal(self, x)

    def copy(self):
        return _infomap.SwigPyIterator_copy(self)

    def next(self):
        return _infomap.SwigPyIterator_next(self)

    def __next__(self):
        return _infomap.SwigPyIterator___next__(self)

    def previous(self):
        return _infomap.SwigPyIterator_previous(self)

    def advance(self, n):
        return _infomap.SwigPyIterator_advance(self, n)

    def __eq__(self, x):
        return _infomap.SwigPyIterator___eq__(self, x)

    def __ne__(self, x):
        return _infomap.SwigPyIterator___ne__(self, x)

    def __iadd__(self, n):
        return _infomap.SwigPyIterator___iadd__(self, n)

    def __isub__(self, n):
        return _infomap.SwigPyIterator___isub__(self, n)

    def __add__(self, n):
        return _infomap.SwigPyIterator___add__(self, n)

    def __sub__(self, *args):
        return _infomap.SwigPyIterator___sub__(self, *args)

    def __iter__(self):
        return self


SwigPyIterator_swigregister = _infomap.SwigPyIterator_swigregister
SwigPyIterator_swigregister(SwigPyIterator)


class StringVector(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(
        self, StringVector, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, StringVector, name)
    __repr__ = _swig_repr

    def iterator(self):
        return _infomap.StringVector_iterator(self)

    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        return _infomap.StringVector___nonzero__(self)

    def __bool__(self):
        return _infomap.StringVector___bool__(self)

    def __len__(self):
        return _infomap.StringVector___len__(self)

    def __getslice__(self, i, j):
        return _infomap.StringVector___getslice__(self, i, j)

    def __setslice__(self, *args):
        return _infomap.StringVector___setslice__(self, *args)

    def __delslice__(self, i, j):
        return _infomap.StringVector___delslice__(self, i, j)

    def __delitem__(self, *args):
        return _infomap.StringVector___delitem__(self, *args)

    def __getitem__(self, *args):
        return _infomap.StringVector___getitem__(self, *args)

    def __setitem__(self, *args):
        return _infomap.StringVector___setitem__(self, *args)

    def pop(self):
        return _infomap.StringVector_pop(self)

    def append(self, x):
        return _infomap.StringVector_append(self, x)

    def empty(self):
        return _infomap.StringVector_empty(self)

    def size(self):
        return _infomap.StringVector_size(self)

    def swap(self, v):
        return _infomap.StringVector_swap(self, v)

    def begin(self):
        return _infomap.StringVector_begin(self)

    def end(self):
        return _infomap.StringVector_end(self)

    def rbegin(self):
        return _infomap.StringVector_rbegin(self)

    def rend(self):
        return _infomap.StringVector_rend(self)

    def clear(self):
        return _infomap.StringVector_clear(self)

    def get_allocator(self):
        return _infomap.StringVector_get_allocator(self)

    def pop_back(self):
        return _infomap.StringVector_pop_back(self)

    def erase(self, *args):
        return _infomap.StringVector_erase(self, *args)

    def __init__(self, *args):
        this = _infomap.new_StringVector(*args)
        try:
            self.this.append(this)
        except Exception:
            self.this = this

    def push_back(self, x):
        return _infomap.StringVector_push_back(self, x)

    def front(self):
        return _infomap.StringVector_front(self)

    def back(self):
        return _infomap.StringVector_back(self)

    def assign(self, n, x):
        return _infomap.StringVector_assign(self, n, x)

    def resize(self, *args):
        return _infomap.StringVector_resize(self, *args)

    def insert(self, *args):
        return _infomap.StringVector_insert(self, *args)

    def reserve(self, n):
        return _infomap.StringVector_reserve(self, n)

    def capacity(self):
        return _infomap.StringVector_capacity(self)

    __swig_destroy__ = _infomap.delete_StringVector
    __del__ = lambda self: None


StringVector_swigregister = _infomap.StringVector_swigregister
StringVector_swigregister(StringVector)


class StateNodeMap(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(
        self, StateNodeMap, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, StateNodeMap, name)
    __repr__ = _swig_repr

    def iterator(self):
        return _infomap.StateNodeMap_iterator(self)

    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        return _infomap.StateNodeMap___nonzero__(self)

    def __bool__(self):
        return _infomap.StateNodeMap___bool__(self)

    def __len__(self):
        return _infomap.StateNodeMap___len__(self)

    def __iter__(self):
        return self.key_iterator()

    def iterkeys(self):
        return self.key_iterator()

    def itervalues(self):
        return self.value_iterator()

    def iteritems(self):
        return self.iterator()

    def __getitem__(self, key):
        return _infomap.StateNodeMap___getitem__(self, key)

    def __delitem__(self, key):
        return _infomap.StateNodeMap___delitem__(self, key)

    def has_key(self, key):
        return _infomap.StateNodeMap_has_key(self, key)

    def keys(self):
        return _infomap.StateNodeMap_keys(self)

    def values(self):
        return _infomap.StateNodeMap_values(self)

    def items(self):
        return _infomap.StateNodeMap_items(self)

    def __contains__(self, key):
        return _infomap.StateNodeMap___contains__(self, key)

    def key_iterator(self):
        return _infomap.StateNodeMap_key_iterator(self)

    def value_iterator(self):
        return _infomap.StateNodeMap_value_iterator(self)

    def __setitem__(self, *args):
        return _infomap.StateNodeMap___setitem__(self, *args)

    def asdict(self):
        return _infomap.StateNodeMap_asdict(self)

    def __init__(self, *args):
        this = _infomap.new_StateNodeMap(*args)
        try:
            self.this.append(this)
        except Exception:
            self.this = this

    def empty(self):
        return _infomap.StateNodeMap_empty(self)

    def size(self):
        return _infomap.StateNodeMap_size(self)

    def swap(self, v):
        return _infomap.StateNodeMap_swap(self, v)

    def begin(self):
        return _infomap.StateNodeMap_begin(self)

    def end(self):
        return _infomap.StateNodeMap_end(self)

    def rbegin(self):
        return _infomap.StateNodeMap_rbegin(self)

    def rend(self):
        return _infomap.StateNodeMap_rend(self)

    def clear(self):
        return _infomap.StateNodeMap_clear(self)

    def get_allocator(self):
        return _infomap.StateNodeMap_get_allocator(self)

    def count(self, x):
        return _infomap.StateNodeMap_count(self, x)

    def erase(self, *args):
        return _infomap.StateNodeMap_erase(self, *args)

    def find(self, x):
        return _infomap.StateNodeMap_find(self, x)

    def lower_bound(self, x):
        return _infomap.StateNodeMap_lower_bound(self, x)

    def upper_bound(self, x):
        return _infomap.StateNodeMap_upper_bound(self, x)

    __swig_destroy__ = _infomap.delete_StateNodeMap
    __del__ = lambda self: None


StateNodeMap_swigregister = _infomap.StateNodeMap_swigregister
StateNodeMap_swigregister(StateNodeMap)


class UIntDeque(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(
        self, UIntDeque, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, UIntDeque, name)
    __repr__ = _swig_repr

    def iterator(self):
        return _infomap.UIntDeque_iterator(self)

    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        return _infomap.UIntDeque___nonzero__(self)

    def __bool__(self):
        return _infomap.UIntDeque___bool__(self)

    def __len__(self):
        return _infomap.UIntDeque___len__(self)

    def __getslice__(self, i, j):
        return _infomap.UIntDeque___getslice__(self, i, j)

    def __setslice__(self, *args):
        return _infomap.UIntDeque___setslice__(self, *args)

    def __delslice__(self, i, j):
        return _infomap.UIntDeque___delslice__(self, i, j)

    def __delitem__(self, *args):
        return _infomap.UIntDeque___delitem__(self, *args)

    def __getitem__(self, *args):
        return _infomap.UIntDeque___getitem__(self, *args)

    def __setitem__(self, *args):
        return _infomap.UIntDeque___setitem__(self, *args)

    def pop(self):
        return _infomap.UIntDeque_pop(self)

    def append(self, x):
        return _infomap.UIntDeque_append(self, x)

    def empty(self):
        return _infomap.UIntDeque_empty(self)

    def size(self):
        return _infomap.UIntDeque_size(self)

    def swap(self, v):
        return _infomap.UIntDeque_swap(self, v)

    def begin(self):
        return _infomap.UIntDeque_begin(self)

    def end(self):
        return _infomap.UIntDeque_end(self)

    def rbegin(self):
        return _infomap.UIntDeque_rbegin(self)

    def rend(self):
        return _infomap.UIntDeque_rend(self)

    def clear(self):
        return _infomap.UIntDeque_clear(self)

    def get_allocator(self):
        return _infomap.UIntDeque_get_allocator(self)

    def pop_back(self):
        return _infomap.UIntDeque_pop_back(self)

    def erase(self, *args):
        return _infomap.UIntDeque_erase(self, *args)

    def __init__(self, *args):
        this = _infomap.new_UIntDeque(*args)
        try:
            self.this.append(this)
        except Exception:
            self.this = this

    def push_back(self, x):
        return _infomap.UIntDeque_push_back(self, x)

    def front(self):
        return _infomap.UIntDeque_front(self)

    def back(self):
        return _infomap.UIntDeque_back(self)

    def assign(self, n, x):
        return _infomap.UIntDeque_assign(self, n, x)

    def resize(self, *args):
        return _infomap.UIntDeque_resize(self, *args)

    def insert(self, *args):
        return _infomap.UIntDeque_insert(self, *args)

    def pop_front(self):
        return _infomap.UIntDeque_pop_front(self)

    def push_front(self, x):
        return _infomap.UIntDeque_push_front(self, x)

    __swig_destroy__ = _infomap.delete_UIntDeque
    __del__ = lambda self: None


UIntDeque_swigregister = _infomap.UIntDeque_swigregister
UIntDeque_swigregister(UIntDeque)


def init(flags):
    return _infomap.init(flags)


init = _infomap.init


def run(*args):
    return _infomap.run(*args)


run = _infomap.run


class Infomap(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(
        self, Infomap, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, Infomap, name)
    __repr__ = _swig_repr

    def __init__(self, flags):
        this = _infomap.new_Infomap(flags)
        try:
            self.this.append(this)
        except Exception:
            self.this = this

    def readInputData(self, filename):
        return _infomap.Infomap_readInputData(self, filename)

    def addLink(self, n1, n2, weight=1.0):
        return _infomap.Infomap_addLink(self, n1, n2, weight)

    def setBipartiteNodesFrom(self, bipartiteStartIndex):
        return _infomap.Infomap_setBipartiteNodesFrom(self,
                                                      bipartiteStartIndex)

    def run(self):
        return _infomap.Infomap_run(self)

    __swig_setmethods__["config"] = _infomap.Infomap_config_set
    __swig_getmethods__["config"] = _infomap.Infomap_config_get
    if _newclass:
        config = _swig_property(_infomap.Infomap_config_get,
                                _infomap.Infomap_config_set)
    __swig_setmethods__["network"] = _infomap.Infomap_network_set
    __swig_getmethods__["network"] = _infomap.Infomap_network_get
    if _newclass:
        network = _swig_property(_infomap.Infomap_network_get,
                                 _infomap.Infomap_network_set)
    __swig_setmethods__["tree"] = _infomap.Infomap_tree_set
    __swig_getmethods__["tree"] = _infomap.Infomap_tree_get
    if _newclass:
        tree = _swig_property(_infomap.Infomap_tree_get,
                              _infomap.Infomap_tree_set)
    __swig_destroy__ = _infomap.delete_Infomap
    __del__ = lambda self: None


Infomap_swigregister = _infomap.Infomap_swigregister
Infomap_swigregister(Infomap)


class MemInfomap(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(
        self, MemInfomap, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, MemInfomap, name)
    __repr__ = _swig_repr

    def __init__(self, flags):
        this = _infomap.new_MemInfomap(flags)
        try:
            self.this.append(this)
        except Exception:
            self.this = this

    def readInputData(self, filename):
        return _infomap.MemInfomap_readInputData(self, filename)

    def addTrigram(self, n1, n2, n3, weight=1.0):
        return _infomap.MemInfomap_addTrigram(self, n1, n2, n3, weight)

    def addStateLink(self, n1PriorState, n1, n2PriorState, n2, weight=1.0):
        return _infomap.MemInfomap_addStateLink(self, n1PriorState, n1,
                                                n2PriorState, n2, weight)

    def addMultiplexLink(self, layer1, node1, layer2, node2, weight=1.0):
        return _infomap.MemInfomap_addMultiplexLink(self, layer1, node1,
                                                    layer2, node2, weight)

    def run(self):
        return _infomap.MemInfomap_run(self)

    __swig_setmethods__["config"] = _infomap.MemInfomap_config_set
    __swig_getmethods__["config"] = _infomap.MemInfomap_config_get
    if _newclass:
        config = _swig_property(_infomap.MemInfomap_config_get,
                                _infomap.MemInfomap_config_set)
    __swig_setmethods__["network"] = _infomap.MemInfomap_network_set
    __swig_getmethods__["network"] = _infomap.MemInfomap_network_get
    if _newclass:
        network = _swig_property(_infomap.MemInfomap_network_get,
                                 _infomap.MemInfomap_network_set)
    __swig_setmethods__["tree"] = _infomap.MemInfomap_tree_set
    __swig_getmethods__["tree"] = _infomap.MemInfomap_tree_get
    if _newclass:
        tree = _swig_property(_infomap.MemInfomap_tree_get,
                              _infomap.MemInfomap_tree_set)
    __swig_destroy__ = _infomap.delete_MemInfomap
    __del__ = lambda self: None


MemInfomap_swigregister = _infomap.MemInfomap_swigregister
MemInfomap_swigregister(MemInfomap)


class ElapsedTime(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(
        self, ElapsedTime, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ElapsedTime, name)
    __repr__ = _swig_repr
    SECONDS_IN_A_MINUTE = _infomap.ElapsedTime_SECONDS_IN_A_MINUTE
    SECONDS_IN_AN_HOUR = _infomap.ElapsedTime_SECONDS_IN_AN_HOUR
    SECONDS_IN_A_DAY = _infomap.ElapsedTime_SECONDS_IN_A_DAY

    def __init__(self, elapsedTime):
        this = _infomap.new_ElapsedTime(elapsedTime)
        try:
            self.this.append(this)
        except Exception:
            self.this = this

    __swig_destroy__ = _infomap.delete_ElapsedTime
    __del__ = lambda self: None

    def getSeconds(self):
        return _infomap.ElapsedTime_getSeconds(self)

    def getMinutes(self):
        return _infomap.ElapsedTime_getMinutes(self)

    def getHours(self):
        return _infomap.ElapsedTime_getHours(self)

    def getDays(self):
        return _infomap.ElapsedTime_getDays(self)


ElapsedTime_swigregister = _infomap.ElapsedTime_swigregister
ElapsedTime_swigregister(ElapsedTime)


class Date(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(
        self, Date, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, Date, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _infomap.new_Date(*args)
        try:
            self.this.append(this)
        except Exception:
            self.this = this

    __swig_destroy__ = _infomap.delete_Date
    __del__ = lambda self: None

    def __sub__(self, date):
        return _infomap.Date___sub__(self, date)


Date_swigregister = _infomap.Date_swigregister
Date_swigregister(Date)


class Config(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(
        self, Config, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, Config, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _infomap.new_Config(*args)
        try:
            self.this.append(this)
        except Exception:
            self.this = this

    def setOptimizationLevel(self, level):
        return _infomap.Config_setOptimizationLevel(self, level)

    def adaptDefaults(self):
        return _infomap.Config_adaptDefaults(self)

    def reset(self):
        return _infomap.Config_reset(self)

    def isUndirected(self):
        return _infomap.Config_isUndirected(self)

    def setUndirected(self):
        return _infomap.Config_setUndirected(self)

    def isUndirectedFlow(self):
        return _infomap.Config_isUndirectedFlow(self)

    def printAsUndirected(self):
        return _infomap.Config_printAsUndirected(self)

    def parseAsUndirected(self):
        return _infomap.Config_parseAsUndirected(self)

    def useTeleportation(self):
        return _infomap.Config_useTeleportation(self)

    def is3gram(self):
        return _infomap.Config_is3gram(self)

    def isMultiplexNetwork(self):
        return _infomap.Config_isMultiplexNetwork(self)

    def isStateNetwork(self):
        return _infomap.Config_isStateNetwork(self)

    def isBipartite(self):
        return _infomap.Config_isBipartite(self)

    def isMemoryInput(self):
        return _infomap.Config_isMemoryInput(self)

    def isMemoryNetwork(self):
        return _infomap.Config_isMemoryNetwork(self)

    def isSimulatedMemoryNetwork(self):
        return _infomap.Config_isSimulatedMemoryNetwork(self)

    def haveOutput(self):
        return _infomap.Config_haveOutput(self)

    def haveModularResultOutput(self):
        return _infomap.Config_haveModularResultOutput(self)

    def elapsedTime(self):
        return _infomap.Config_elapsedTime(self)

    __swig_setmethods__["parsedArgs"] = _infomap.Config_parsedArgs_set
    __swig_getmethods__["parsedArgs"] = _infomap.Config_parsedArgs_get
    if _newclass:
        parsedArgs = _swig_property(_infomap.Config_parsedArgs_get,
                                    _infomap.Config_parsedArgs_set)
    __swig_setmethods__["networkFile"] = _infomap.Config_networkFile_set
    __swig_getmethods__["networkFile"] = _infomap.Config_networkFile_get
    if _newclass:
        networkFile = _swig_property(_infomap.Config_networkFile_get,
                                     _infomap.Config_networkFile_set)
    __swig_setmethods__[
        "additionalInput"] = _infomap.Config_additionalInput_set
    __swig_getmethods__[
        "additionalInput"] = _infomap.Config_additionalInput_get
    if _newclass:
        additionalInput = _swig_property(_infomap.Config_additionalInput_get,
                                         _infomap.Config_additionalInput_set)
    __swig_setmethods__["inputFormat"] = _infomap.Config_inputFormat_set
    __swig_getmethods__["inputFormat"] = _infomap.Config_inputFormat_get
    if _newclass:
        inputFormat = _swig_property(_infomap.Config_inputFormat_get,
                                     _infomap.Config_inputFormat_set)
    __swig_setmethods__["withMemory"] = _infomap.Config_withMemory_set
    __swig_getmethods__["withMemory"] = _infomap.Config_withMemory_get
    if _newclass:
        withMemory = _swig_property(_infomap.Config_withMemory_get,
                                    _infomap.Config_withMemory_set)
    __swig_setmethods__["bipartite"] = _infomap.Config_bipartite_set
    __swig_getmethods__["bipartite"] = _infomap.Config_bipartite_get
    if _newclass:
        bipartite = _swig_property(_infomap.Config_bipartite_get,
                                   _infomap.Config_bipartite_set)
    __swig_setmethods__[
        "skipAdjustBipartiteFlow"] = _infomap.Config_skipAdjustBipartiteFlow_set
    __swig_getmethods__[
        "skipAdjustBipartiteFlow"] = _infomap.Config_skipAdjustBipartiteFlow_get
    if _newclass:
        skipAdjustBipartiteFlow = _swig_property(
            _infomap.Config_skipAdjustBipartiteFlow_get,
            _infomap.Config_skipAdjustBipartiteFlow_set)
    __swig_setmethods__[
        "multiplexAddMissingNodes"] = _infomap.Config_multiplexAddMissingNodes_set
    __swig_getmethods__[
        "multiplexAddMissingNodes"] = _infomap.Config_multiplexAddMissingNodes_get
    if _newclass:
        multiplexAddMissingNodes = _swig_property(
            _infomap.Config_multiplexAddMissingNodes_get,
            _infomap.Config_multiplexAddMissingNodes_set)
    __swig_setmethods__["hardPartitions"] = _infomap.Config_hardPartitions_set
    __swig_getmethods__["hardPartitions"] = _infomap.Config_hardPartitions_get
    if _newclass:
        hardPartitions = _swig_property(_infomap.Config_hardPartitions_get,
                                        _infomap.Config_hardPartitions_set)
    __swig_setmethods__[
        "nonBacktracking"] = _infomap.Config_nonBacktracking_set
    __swig_getmethods__[
        "nonBacktracking"] = _infomap.Config_nonBacktracking_get
    if _newclass:
        nonBacktracking = _swig_property(_infomap.Config_nonBacktracking_get,
                                         _infomap.Config_nonBacktracking_set)
    __swig_setmethods__[
        "parseWithoutIOStreams"] = _infomap.Config_parseWithoutIOStreams_set
    __swig_getmethods__[
        "parseWithoutIOStreams"] = _infomap.Config_parseWithoutIOStreams_get
    if _newclass:
        parseWithoutIOStreams = _swig_property(
            _infomap.Config_parseWithoutIOStreams_get,
            _infomap.Config_parseWithoutIOStreams_set)
    __swig_setmethods__[
        "zeroBasedNodeNumbers"] = _infomap.Config_zeroBasedNodeNumbers_set
    __swig_getmethods__[
        "zeroBasedNodeNumbers"] = _infomap.Config_zeroBasedNodeNumbers_get
    if _newclass:
        zeroBasedNodeNumbers = _swig_property(
            _infomap.Config_zeroBasedNodeNumbers_get,
            _infomap.Config_zeroBasedNodeNumbers_set)
    __swig_setmethods__[
        "includeSelfLinks"] = _infomap.Config_includeSelfLinks_set
    __swig_getmethods__[
        "includeSelfLinks"] = _infomap.Config_includeSelfLinks_get
    if _newclass:
        includeSelfLinks = _swig_property(_infomap.Config_includeSelfLinks_get,
                                          _infomap.Config_includeSelfLinks_set)
    __swig_setmethods__[
        "ignoreEdgeWeights"] = _infomap.Config_ignoreEdgeWeights_set
    __swig_getmethods__[
        "ignoreEdgeWeights"] = _infomap.Config_ignoreEdgeWeights_get
    if _newclass:
        ignoreEdgeWeights = _swig_property(
            _infomap.Config_ignoreEdgeWeights_get,
            _infomap.Config_ignoreEdgeWeights_set)
    __swig_setmethods__[
        "completeDanglingMemoryNodes"] = _infomap.Config_completeDanglingMemoryNodes_set
    __swig_getmethods__[
        "completeDanglingMemoryNodes"] = _infomap.Config_completeDanglingMemoryNodes_get
    if _newclass:
        completeDanglingMemoryNodes = _swig_property(
            _infomap.Config_completeDanglingMemoryNodes_get,
            _infomap.Config_completeDanglingMemoryNodes_set)
    __swig_setmethods__["nodeLimit"] = _infomap.Config_nodeLimit_set
    __swig_getmethods__["nodeLimit"] = _infomap.Config_nodeLimit_get
    if _newclass:
        nodeLimit = _swig_property(_infomap.Config_nodeLimit_get,
                                   _infomap.Config_nodeLimit_set)
    __swig_setmethods__[
        "weightThreshold"] = _infomap.Config_weightThreshold_set
    __swig_getmethods__[
        "weightThreshold"] = _infomap.Config_weightThreshold_get
    if _newclass:
        weightThreshold = _swig_property(_infomap.Config_weightThreshold_get,
                                         _infomap.Config_weightThreshold_set)
    __swig_setmethods__[
        "preClusterMultiplex"] = _infomap.Config_preClusterMultiplex_set
    __swig_getmethods__[
        "preClusterMultiplex"] = _infomap.Config_preClusterMultiplex_get
    if _newclass:
        preClusterMultiplex = _swig_property(
            _infomap.Config_preClusterMultiplex_get,
            _infomap.Config_preClusterMultiplex_set)
    __swig_setmethods__[
        "clusterDataFile"] = _infomap.Config_clusterDataFile_set
    __swig_getmethods__[
        "clusterDataFile"] = _infomap.Config_clusterDataFile_get
    if _newclass:
        clusterDataFile = _swig_property(_infomap.Config_clusterDataFile_get,
                                         _infomap.Config_clusterDataFile_set)
    __swig_setmethods__["noInfomap"] = _infomap.Config_noInfomap_set
    __swig_getmethods__["noInfomap"] = _infomap.Config_noInfomap_get
    if _newclass:
        noInfomap = _swig_property(_infomap.Config_noInfomap_get,
                                   _infomap.Config_noInfomap_set)
    __swig_setmethods__["twoLevel"] = _infomap.Config_twoLevel_set
    __swig_getmethods__["twoLevel"] = _infomap.Config_twoLevel_get
    if _newclass:
        twoLevel = _swig_property(_infomap.Config_twoLevel_get,
                                  _infomap.Config_twoLevel_set)
    __swig_setmethods__["directed"] = _infomap.Config_directed_set
    __swig_getmethods__["directed"] = _infomap.Config_directed_get
    if _newclass:
        directed = _swig_property(_infomap.Config_directed_get,
                                  _infomap.Config_directed_set)
    __swig_setmethods__["undirdir"] = _infomap.Config_undirdir_set
    __swig_getmethods__["undirdir"] = _infomap.Config_undirdir_get
    if _newclass:
        undirdir = _swig_property(_infomap.Config_undirdir_get,
                                  _infomap.Config_undirdir_set)
    __swig_setmethods__["outdirdir"] = _infomap.Config_outdirdir_set
    __swig_getmethods__["outdirdir"] = _infomap.Config_outdirdir_get
    if _newclass:
        outdirdir = _swig_property(_infomap.Config_outdirdir_get,
                                   _infomap.Config_outdirdir_set)
    __swig_setmethods__["rawdir"] = _infomap.Config_rawdir_set
    __swig_getmethods__["rawdir"] = _infomap.Config_rawdir_get
    if _newclass:
        rawdir = _swig_property(_infomap.Config_rawdir_get,
                                _infomap.Config_rawdir_set)
    __swig_setmethods__[
        "recordedTeleportation"] = _infomap.Config_recordedTeleportation_set
    __swig_getmethods__[
        "recordedTeleportation"] = _infomap.Config_recordedTeleportation_get
    if _newclass:
        recordedTeleportation = _swig_property(
            _infomap.Config_recordedTeleportation_get,
            _infomap.Config_recordedTeleportation_set)
    __swig_setmethods__[
        "teleportToNodes"] = _infomap.Config_teleportToNodes_set
    __swig_getmethods__[
        "teleportToNodes"] = _infomap.Config_teleportToNodes_get
    if _newclass:
        teleportToNodes = _swig_property(_infomap.Config_teleportToNodes_get,
                                         _infomap.Config_teleportToNodes_set)
    __swig_setmethods__[
        "teleportationProbability"] = _infomap.Config_teleportationProbability_set
    __swig_getmethods__[
        "teleportationProbability"] = _infomap.Config_teleportationProbability_get
    if _newclass:
        teleportationProbability = _swig_property(
            _infomap.Config_teleportationProbability_get,
            _infomap.Config_teleportationProbability_set)
    __swig_setmethods__[
        "selfTeleportationProbability"] = _infomap.Config_selfTeleportationProbability_set
    __swig_getmethods__[
        "selfTeleportationProbability"] = _infomap.Config_selfTeleportationProbability_get
    if _newclass:
        selfTeleportationProbability = _swig_property(
            _infomap.Config_selfTeleportationProbability_get,
            _infomap.Config_selfTeleportationProbability_set)
    __swig_setmethods__["markovTime"] = _infomap.Config_markovTime_set
    __swig_getmethods__["markovTime"] = _infomap.Config_markovTime_get
    if _newclass:
        markovTime = _swig_property(_infomap.Config_markovTime_get,
                                    _infomap.Config_markovTime_set)
    __swig_setmethods__[
        "variableMarkovTime"] = _infomap.Config_variableMarkovTime_set
    __swig_getmethods__[
        "variableMarkovTime"] = _infomap.Config_variableMarkovTime_get
    if _newclass:
        variableMarkovTime = _swig_property(
            _infomap.Config_variableMarkovTime_get,
            _infomap.Config_variableMarkovTime_set)
    __swig_setmethods__[
        "preferredNumberOfModules"] = _infomap.Config_preferredNumberOfModules_set
    __swig_getmethods__[
        "preferredNumberOfModules"] = _infomap.Config_preferredNumberOfModules_get
    if _newclass:
        preferredNumberOfModules = _swig_property(
            _infomap.Config_preferredNumberOfModules_get,
            _infomap.Config_preferredNumberOfModules_set)
    __swig_setmethods__[
        "multiplexRelaxRate"] = _infomap.Config_multiplexRelaxRate_set
    __swig_getmethods__[
        "multiplexRelaxRate"] = _infomap.Config_multiplexRelaxRate_get
    if _newclass:
        multiplexRelaxRate = _swig_property(
            _infomap.Config_multiplexRelaxRate_get,
            _infomap.Config_multiplexRelaxRate_set)
    __swig_setmethods__[
        "multiplexJSRelaxRate"] = _infomap.Config_multiplexJSRelaxRate_set
    __swig_getmethods__[
        "multiplexJSRelaxRate"] = _infomap.Config_multiplexJSRelaxRate_get
    if _newclass:
        multiplexJSRelaxRate = _swig_property(
            _infomap.Config_multiplexJSRelaxRate_get,
            _infomap.Config_multiplexJSRelaxRate_set)
    __swig_setmethods__[
        "multiplexJSRelaxLimit"] = _infomap.Config_multiplexJSRelaxLimit_set
    __swig_getmethods__[
        "multiplexJSRelaxLimit"] = _infomap.Config_multiplexJSRelaxLimit_get
    if _newclass:
        multiplexJSRelaxLimit = _swig_property(
            _infomap.Config_multiplexJSRelaxLimit_get,
            _infomap.Config_multiplexJSRelaxLimit_set)
    __swig_setmethods__[
        "multiplexRelaxLimit"] = _infomap.Config_multiplexRelaxLimit_set
    __swig_getmethods__[
        "multiplexRelaxLimit"] = _infomap.Config_multiplexRelaxLimit_get
    if _newclass:
        multiplexRelaxLimit = _swig_property(
            _infomap.Config_multiplexRelaxLimit_get,
            _infomap.Config_multiplexRelaxLimit_set)
    __swig_setmethods__[
        "seedToRandomNumberGenerator"] = _infomap.Config_seedToRandomNumberGenerator_set
    __swig_getmethods__[
        "seedToRandomNumberGenerator"] = _infomap.Config_seedToRandomNumberGenerator_get
    if _newclass:
        seedToRandomNumberGenerator = _swig_property(
            _infomap.Config_seedToRandomNumberGenerator_get,
            _infomap.Config_seedToRandomNumberGenerator_set)
    __swig_setmethods__["numTrials"] = _infomap.Config_numTrials_set
    __swig_getmethods__["numTrials"] = _infomap.Config_numTrials_get
    if _newclass:
        numTrials = _swig_property(_infomap.Config_numTrials_get,
                                   _infomap.Config_numTrials_set)
    __swig_setmethods__[
        "minimumCodelengthImprovement"] = _infomap.Config_minimumCodelengthImprovement_set
    __swig_getmethods__[
        "minimumCodelengthImprovement"] = _infomap.Config_minimumCodelengthImprovement_get
    if _newclass:
        minimumCodelengthImprovement = _swig_property(
            _infomap.Config_minimumCodelengthImprovement_get,
            _infomap.Config_minimumCodelengthImprovement_set)
    __swig_setmethods__[
        "minimumSingleNodeCodelengthImprovement"] = _infomap.Config_minimumSingleNodeCodelengthImprovement_set
    __swig_getmethods__[
        "minimumSingleNodeCodelengthImprovement"] = _infomap.Config_minimumSingleNodeCodelengthImprovement_get
    if _newclass:
        minimumSingleNodeCodelengthImprovement = _swig_property(
            _infomap.Config_minimumSingleNodeCodelengthImprovement_get,
            _infomap.Config_minimumSingleNodeCodelengthImprovement_set)
    __swig_setmethods__[
        "randomizeCoreLoopLimit"] = _infomap.Config_randomizeCoreLoopLimit_set
    __swig_getmethods__[
        "randomizeCoreLoopLimit"] = _infomap.Config_randomizeCoreLoopLimit_get
    if _newclass:
        randomizeCoreLoopLimit = _swig_property(
            _infomap.Config_randomizeCoreLoopLimit_get,
            _infomap.Config_randomizeCoreLoopLimit_set)
    __swig_setmethods__["coreLoopLimit"] = _infomap.Config_coreLoopLimit_set
    __swig_getmethods__["coreLoopLimit"] = _infomap.Config_coreLoopLimit_get
    if _newclass:
        coreLoopLimit = _swig_property(_infomap.Config_coreLoopLimit_get,
                                       _infomap.Config_coreLoopLimit_set)
    __swig_setmethods__[
        "levelAggregationLimit"] = _infomap.Config_levelAggregationLimit_set
    __swig_getmethods__[
        "levelAggregationLimit"] = _infomap.Config_levelAggregationLimit_get
    if _newclass:
        levelAggregationLimit = _swig_property(
            _infomap.Config_levelAggregationLimit_get,
            _infomap.Config_levelAggregationLimit_set)
    __swig_setmethods__[
        "tuneIterationLimit"] = _infomap.Config_tuneIterationLimit_set
    __swig_getmethods__[
        "tuneIterationLimit"] = _infomap.Config_tuneIterationLimit_get
    if _newclass:
        tuneIterationLimit = _swig_property(
            _infomap.Config_tuneIterationLimit_get,
            _infomap.Config_tuneIterationLimit_set)
    __swig_setmethods__[
        "minimumRelativeTuneIterationImprovement"] = _infomap.Config_minimumRelativeTuneIterationImprovement_set
    __swig_getmethods__[
        "minimumRelativeTuneIterationImprovement"] = _infomap.Config_minimumRelativeTuneIterationImprovement_get
    if _newclass:
        minimumRelativeTuneIterationImprovement = _swig_property(
            _infomap.Config_minimumRelativeTuneIterationImprovement_get,
            _infomap.Config_minimumRelativeTuneIterationImprovement_set)
    __swig_setmethods__[
        "fastCoarseTunePartition"] = _infomap.Config_fastCoarseTunePartition_set
    __swig_getmethods__[
        "fastCoarseTunePartition"] = _infomap.Config_fastCoarseTunePartition_get
    if _newclass:
        fastCoarseTunePartition = _swig_property(
            _infomap.Config_fastCoarseTunePartition_get,
            _infomap.Config_fastCoarseTunePartition_set)
    __swig_setmethods__[
        "alternateCoarseTuneLevel"] = _infomap.Config_alternateCoarseTuneLevel_set
    __swig_getmethods__[
        "alternateCoarseTuneLevel"] = _infomap.Config_alternateCoarseTuneLevel_get
    if _newclass:
        alternateCoarseTuneLevel = _swig_property(
            _infomap.Config_alternateCoarseTuneLevel_get,
            _infomap.Config_alternateCoarseTuneLevel_set)
    __swig_setmethods__[
        "coarseTuneLevel"] = _infomap.Config_coarseTuneLevel_set
    __swig_getmethods__[
        "coarseTuneLevel"] = _infomap.Config_coarseTuneLevel_get
    if _newclass:
        coarseTuneLevel = _swig_property(_infomap.Config_coarseTuneLevel_get,
                                         _infomap.Config_coarseTuneLevel_set)
    __swig_setmethods__[
        "fastHierarchicalSolution"] = _infomap.Config_fastHierarchicalSolution_set
    __swig_getmethods__[
        "fastHierarchicalSolution"] = _infomap.Config_fastHierarchicalSolution_get
    if _newclass:
        fastHierarchicalSolution = _swig_property(
            _infomap.Config_fastHierarchicalSolution_get,
            _infomap.Config_fastHierarchicalSolution_set)
    __swig_setmethods__[
        "fastFirstIteration"] = _infomap.Config_fastFirstIteration_set
    __swig_getmethods__[
        "fastFirstIteration"] = _infomap.Config_fastFirstIteration_get
    if _newclass:
        fastFirstIteration = _swig_property(
            _infomap.Config_fastFirstIteration_get,
            _infomap.Config_fastFirstIteration_set)
    __swig_setmethods__[
        "lowMemoryPriority"] = _infomap.Config_lowMemoryPriority_set
    __swig_getmethods__[
        "lowMemoryPriority"] = _infomap.Config_lowMemoryPriority_get
    if _newclass:
        lowMemoryPriority = _swig_property(
            _infomap.Config_lowMemoryPriority_get,
            _infomap.Config_lowMemoryPriority_set)
    __swig_setmethods__[
        "innerParallelization"] = _infomap.Config_innerParallelization_set
    __swig_getmethods__[
        "innerParallelization"] = _infomap.Config_innerParallelization_get
    if _newclass:
        innerParallelization = _swig_property(
            _infomap.Config_innerParallelization_get,
            _infomap.Config_innerParallelization_set)
    __swig_setmethods__[
        "resetConfigBeforeRecursion"] = _infomap.Config_resetConfigBeforeRecursion_set
    __swig_getmethods__[
        "resetConfigBeforeRecursion"] = _infomap.Config_resetConfigBeforeRecursion_get
    if _newclass:
        resetConfigBeforeRecursion = _swig_property(
            _infomap.Config_resetConfigBeforeRecursion_get,
            _infomap.Config_resetConfigBeforeRecursion_set)
    __swig_setmethods__["outDirectory"] = _infomap.Config_outDirectory_set
    __swig_getmethods__["outDirectory"] = _infomap.Config_outDirectory_get
    if _newclass:
        outDirectory = _swig_property(_infomap.Config_outDirectory_get,
                                      _infomap.Config_outDirectory_set)
    __swig_setmethods__["outName"] = _infomap.Config_outName_set
    __swig_getmethods__["outName"] = _infomap.Config_outName_get
    if _newclass:
        outName = _swig_property(_infomap.Config_outName_get,
                                 _infomap.Config_outName_set)
    __swig_setmethods__[
        "originallyUndirected"] = _infomap.Config_originallyUndirected_set
    __swig_getmethods__[
        "originallyUndirected"] = _infomap.Config_originallyUndirected_get
    if _newclass:
        originallyUndirected = _swig_property(
            _infomap.Config_originallyUndirected_get,
            _infomap.Config_originallyUndirected_set)
    __swig_setmethods__["printTree"] = _infomap.Config_printTree_set
    __swig_getmethods__["printTree"] = _infomap.Config_printTree_get
    if _newclass:
        printTree = _swig_property(_infomap.Config_printTree_get,
                                   _infomap.Config_printTree_set)
    __swig_setmethods__["printFlowTree"] = _infomap.Config_printFlowTree_set
    __swig_getmethods__["printFlowTree"] = _infomap.Config_printFlowTree_get
    if _newclass:
        printFlowTree = _swig_property(_infomap.Config_printFlowTree_get,
                                       _infomap.Config_printFlowTree_set)
    __swig_setmethods__["printMap"] = _infomap.Config_printMap_set
    __swig_getmethods__["printMap"] = _infomap.Config_printMap_get
    if _newclass:
        printMap = _swig_property(_infomap.Config_printMap_get,
                                  _infomap.Config_printMap_set)
    __swig_setmethods__["printClu"] = _infomap.Config_printClu_set
    __swig_getmethods__["printClu"] = _infomap.Config_printClu_get
    if _newclass:
        printClu = _swig_property(_infomap.Config_printClu_get,
                                  _infomap.Config_printClu_set)
    __swig_setmethods__["printNodeRanks"] = _infomap.Config_printNodeRanks_set
    __swig_getmethods__["printNodeRanks"] = _infomap.Config_printNodeRanks_get
    if _newclass:
        printNodeRanks = _swig_property(_infomap.Config_printNodeRanks_get,
                                        _infomap.Config_printNodeRanks_set)
    __swig_setmethods__[
        "printFlowNetwork"] = _infomap.Config_printFlowNetwork_set
    __swig_getmethods__[
        "printFlowNetwork"] = _infomap.Config_printFlowNetwork_get
    if _newclass:
        printFlowNetwork = _swig_property(_infomap.Config_printFlowNetwork_get,
                                          _infomap.Config_printFlowNetwork_set)
    __swig_setmethods__[
        "printPajekNetwork"] = _infomap.Config_printPajekNetwork_set
    __swig_getmethods__[
        "printPajekNetwork"] = _infomap.Config_printPajekNetwork_get
    if _newclass:
        printPajekNetwork = _swig_property(
            _infomap.Config_printPajekNetwork_get,
            _infomap.Config_printPajekNetwork_set)
    __swig_setmethods__[
        "printStateNetwork"] = _infomap.Config_printStateNetwork_set
    __swig_getmethods__[
        "printStateNetwork"] = _infomap.Config_printStateNetwork_get
    if _newclass:
        printStateNetwork = _swig_property(
            _infomap.Config_printStateNetwork_get,
            _infomap.Config_printStateNetwork_set)
    __swig_setmethods__[
        "printBinaryTree"] = _infomap.Config_printBinaryTree_set
    __swig_getmethods__[
        "printBinaryTree"] = _infomap.Config_printBinaryTree_get
    if _newclass:
        printBinaryTree = _swig_property(_infomap.Config_printBinaryTree_get,
                                         _infomap.Config_printBinaryTree_set)
    __swig_setmethods__[
        "printBinaryFlowTree"] = _infomap.Config_printBinaryFlowTree_set
    __swig_getmethods__[
        "printBinaryFlowTree"] = _infomap.Config_printBinaryFlowTree_get
    if _newclass:
        printBinaryFlowTree = _swig_property(
            _infomap.Config_printBinaryFlowTree_get,
            _infomap.Config_printBinaryFlowTree_set)
    __swig_setmethods__["printExpanded"] = _infomap.Config_printExpanded_set
    __swig_getmethods__["printExpanded"] = _infomap.Config_printExpanded_get
    if _newclass:
        printExpanded = _swig_property(_infomap.Config_printExpanded_get,
                                       _infomap.Config_printExpanded_set)
    __swig_setmethods__["printAllTrials"] = _infomap.Config_printAllTrials_set
    __swig_getmethods__["printAllTrials"] = _infomap.Config_printAllTrials_get
    if _newclass:
        printAllTrials = _swig_property(_infomap.Config_printAllTrials_get,
                                        _infomap.Config_printAllTrials_set)
    __swig_setmethods__["noFileOutput"] = _infomap.Config_noFileOutput_set
    __swig_getmethods__["noFileOutput"] = _infomap.Config_noFileOutput_get
    if _newclass:
        noFileOutput = _swig_property(_infomap.Config_noFileOutput_get,
                                      _infomap.Config_noFileOutput_set)
    __swig_setmethods__["verbosity"] = _infomap.Config_verbosity_set
    __swig_getmethods__["verbosity"] = _infomap.Config_verbosity_get
    if _newclass:
        verbosity = _swig_property(_infomap.Config_verbosity_get,
                                   _infomap.Config_verbosity_set)
    __swig_setmethods__[
        "verboseNumberPrecision"] = _infomap.Config_verboseNumberPrecision_set
    __swig_getmethods__[
        "verboseNumberPrecision"] = _infomap.Config_verboseNumberPrecision_get
    if _newclass:
        verboseNumberPrecision = _swig_property(
            _infomap.Config_verboseNumberPrecision_get,
            _infomap.Config_verboseNumberPrecision_set)
    __swig_setmethods__["silent"] = _infomap.Config_silent_set
    __swig_getmethods__["silent"] = _infomap.Config_silent_get
    if _newclass:
        silent = _swig_property(_infomap.Config_silent_get,
                                _infomap.Config_silent_set)
    __swig_setmethods__["benchmark"] = _infomap.Config_benchmark_set
    __swig_getmethods__["benchmark"] = _infomap.Config_benchmark_get
    if _newclass:
        benchmark = _swig_property(_infomap.Config_benchmark_get,
                                   _infomap.Config_benchmark_set)
    __swig_setmethods__[
        "maxNodeIndexVisible"] = _infomap.Config_maxNodeIndexVisible_set
    __swig_getmethods__[
        "maxNodeIndexVisible"] = _infomap.Config_maxNodeIndexVisible_get
    if _newclass:
        maxNodeIndexVisible = _swig_property(
            _infomap.Config_maxNodeIndexVisible_get,
            _infomap.Config_maxNodeIndexVisible_set)
    __swig_setmethods__["showBiNodes"] = _infomap.Config_showBiNodes_set
    __swig_getmethods__["showBiNodes"] = _infomap.Config_showBiNodes_get
    if _newclass:
        showBiNodes = _swig_property(_infomap.Config_showBiNodes_get,
                                     _infomap.Config_showBiNodes_set)
    __swig_setmethods__[
        "hideBipartiteNodes"] = _infomap.Config_hideBipartiteNodes_set
    __swig_getmethods__[
        "hideBipartiteNodes"] = _infomap.Config_hideBipartiteNodes_get
    if _newclass:
        hideBipartiteNodes = _swig_property(
            _infomap.Config_hideBipartiteNodes_get,
            _infomap.Config_hideBipartiteNodes_set)
    __swig_setmethods__[
        "minBipartiteNodeIndex"] = _infomap.Config_minBipartiteNodeIndex_set
    __swig_getmethods__[
        "minBipartiteNodeIndex"] = _infomap.Config_minBipartiteNodeIndex_get
    if _newclass:
        minBipartiteNodeIndex = _swig_property(
            _infomap.Config_minBipartiteNodeIndex_get,
            _infomap.Config_minBipartiteNodeIndex_set)
    __swig_setmethods__["startDate"] = _infomap.Config_startDate_set
    __swig_getmethods__["startDate"] = _infomap.Config_startDate_get
    if _newclass:
        startDate = _swig_property(_infomap.Config_startDate_get,
                                   _infomap.Config_startDate_set)
    __swig_setmethods__["version"] = _infomap.Config_version_set
    __swig_getmethods__["version"] = _infomap.Config_version_get
    if _newclass:
        version = _swig_property(_infomap.Config_version_get,
                                 _infomap.Config_version_set)
    __swig_destroy__ = _infomap.delete_Config
    __del__ = lambda self: None


Config_swigregister = _infomap.Config_swigregister
Config_swigregister(Config)


class Network(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(
        self, Network, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, Network, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _infomap.new_Network(*args)
        try:
            self.this.append(this)
        except Exception:
            self.this = this

    __swig_destroy__ = _infomap.delete_Network
    __del__ = lambda self: None

    def setConfig(self, config):
        return _infomap.Network_setConfig(self, config)

    def readInputData(self, *args):
        return _infomap.Network_readInputData(self, *args)

    def addNodes(self, names):
        return _infomap.Network_addNodes(self, names)

    def addNode(self, nodeIndex):
        return _infomap.Network_addNode(self, nodeIndex)

    def addLink(self, n1, n2, weight=1.0):
        return _infomap.Network_addLink(self, n1, n2, weight)

    def addBipartiteLink(self, *args):
        return _infomap.Network_addBipartiteLink(self, *args)

    def setBipartiteNodesFrom(self, bipartiteStartIndex):
        return _infomap.Network_setBipartiteNodesFrom(self,
                                                      bipartiteStartIndex)

    def finalizeAndCheckNetwork(self,
                                printSummary=True,
                                desiredNumberOfNodes=0):
        return _infomap.Network_finalizeAndCheckNetwork(
            self, printSummary, desiredNumberOfNodes)

    def printParsingResult(self, onlySummary=False):
        return _infomap.Network_printParsingResult(self, onlySummary)

    def getParsingResultSummary(self):
        return _infomap.Network_getParsingResultSummary(self)

    def printNetworkAsPajek(self, filename):
        return _infomap.Network_printNetworkAsPajek(self, filename)

    def printStateNetwork(self, filename):
        return _infomap.Network_printStateNetwork(self, filename)

    def numNodes(self):
        return _infomap.Network_numNodes(self)

    def nodeNames(self):
        return _infomap.Network_nodeNames(self)

    def nodeWeights(self):
        return _infomap.Network_nodeWeights(self)

    def sumNodeWeights(self):
        return _infomap.Network_sumNodeWeights(self)

    def outDegree(self):
        return _infomap.Network_outDegree(self)

    def sumLinkOutWeight(self):
        return _infomap.Network_sumLinkOutWeight(self)

    def haveNode(self, nodeIndex):
        return _infomap.Network_haveNode(self, nodeIndex)

    def linkMap(self):
        return _infomap.Network_linkMap(self)

    def numLinks(self):
        return _infomap.Network_numLinks(self)

    def totalLinkWeight(self):
        return _infomap.Network_totalLinkWeight(self)

    def totalSelfLinkWeight(self):
        return _infomap.Network_totalSelfLinkWeight(self)

    def isBipartite(self):
        return _infomap.Network_isBipartite(self)

    def numBipartiteNodes(self):
        return _infomap.Network_numBipartiteNodes(self)

    def initNodeNames(self):
        return _infomap.Network_initNodeNames(self)

    def swapNodeNames(self, target):
        return _infomap.Network_swapNodeNames(self, target)

    def generateOppositeLinkMap(self, oppositeLinks):
        return _infomap.Network_generateOppositeLinkMap(self, oppositeLinks)

    def disposeLinks(self):
        return _infomap.Network_disposeLinks(self)

    def config(self):
        return _infomap.Network_config(self)

    def isFinalized(self):
        return _infomap.Network_isFinalized(self)


Network_swigregister = _infomap.Network_swigregister
Network_swigregister(Network)


class Bigram(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(
        self, Bigram, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, Bigram, name)
    __repr__ = _swig_repr
    __swig_setmethods__["first"] = _infomap.Bigram_first_set
    __swig_getmethods__["first"] = _infomap.Bigram_first_get
    if _newclass:
        first = _swig_property(_infomap.Bigram_first_get,
                               _infomap.Bigram_first_set)
    __swig_setmethods__["second"] = _infomap.Bigram_second_set
    __swig_getmethods__["second"] = _infomap.Bigram_second_get
    if _newclass:
        second = _swig_property(_infomap.Bigram_second_get,
                                _infomap.Bigram_second_set)

    def __init__(self, first=0, second=0):
        this = _infomap.new_Bigram(first, second)
        try:
            self.this.append(this)
        except Exception:
            self.this = this

    def __lt__(self, other):
        return _infomap.Bigram___lt__(self, other)

    __swig_destroy__ = _infomap.delete_Bigram
    __del__ = lambda self: None


Bigram_swigregister = _infomap.Bigram_swigregister
Bigram_swigregister(Bigram)


class BipartiteLink(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(
        self, BipartiteLink, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, BipartiteLink, name)
    __repr__ = _swig_repr
    __swig_setmethods__["featureNode"] = _infomap.BipartiteLink_featureNode_set
    __swig_getmethods__["featureNode"] = _infomap.BipartiteLink_featureNode_get
    if _newclass:
        featureNode = _swig_property(_infomap.BipartiteLink_featureNode_get,
                                     _infomap.BipartiteLink_featureNode_set)
    __swig_setmethods__["node"] = _infomap.BipartiteLink_node_set
    __swig_getmethods__["node"] = _infomap.BipartiteLink_node_get
    if _newclass:
        node = _swig_property(_infomap.BipartiteLink_node_get,
                              _infomap.BipartiteLink_node_set)
    __swig_setmethods__["swapOrder"] = _infomap.BipartiteLink_swapOrder_set
    __swig_getmethods__["swapOrder"] = _infomap.BipartiteLink_swapOrder_get
    if _newclass:
        swapOrder = _swig_property(_infomap.BipartiteLink_swapOrder_get,
                                   _infomap.BipartiteLink_swapOrder_set)

    def __init__(self, featureNode=0, node=0, swapOrder=False):
        this = _infomap.new_BipartiteLink(featureNode, node, swapOrder)
        try:
            self.this.append(this)
        except Exception:
            self.this = this

    def __lt__(self, other):
        return _infomap.BipartiteLink___lt__(self, other)

    __swig_destroy__ = _infomap.delete_BipartiteLink
    __del__ = lambda self: None


BipartiteLink_swigregister = _infomap.BipartiteLink_swigregister
BipartiteLink_swigregister(BipartiteLink)


class Weight(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(
        self, Weight, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, Weight, name)
    __repr__ = _swig_repr
    __swig_setmethods__["weight"] = _infomap.Weight_weight_set
    __swig_getmethods__["weight"] = _infomap.Weight_weight_get
    if _newclass:
        weight = _swig_property(_infomap.Weight_weight_get,
                                _infomap.Weight_weight_set)

    def __init__(self, weight=0):
        this = _infomap.new_Weight(weight)
        try:
            self.this.append(this)
        except Exception:
            self.this = this

    def __iadd__(self, w):
        return _infomap.Weight___iadd__(self, w)

    __swig_destroy__ = _infomap.delete_Weight
    __del__ = lambda self: None


Weight_swigregister = _infomap.Weight_swigregister
Weight_swigregister(Weight)


class Triple(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(
        self, Triple, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, Triple, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _infomap.new_Triple(*args)
        try:
            self.this.append(this)
        except Exception:
            self.this = this

    __swig_destroy__ = _infomap.delete_Triple
    __del__ = lambda self: None

    def __lt__(self, other):
        return _infomap.Triple___lt__(self, other)

    def __eq__(self, other):
        return _infomap.Triple___eq__(self, other)

    __swig_setmethods__["n1"] = _infomap.Triple_n1_set
    __swig_getmethods__["n1"] = _infomap.Triple_n1_get
    if _newclass:
        n1 = _swig_property(_infomap.Triple_n1_get, _infomap.Triple_n1_set)
    __swig_setmethods__["n2"] = _infomap.Triple_n2_set
    __swig_getmethods__["n2"] = _infomap.Triple_n2_get
    if _newclass:
        n2 = _swig_property(_infomap.Triple_n2_get, _infomap.Triple_n2_set)
    __swig_setmethods__["n3"] = _infomap.Triple_n3_set
    __swig_getmethods__["n3"] = _infomap.Triple_n3_get
    if _newclass:
        n3 = _swig_property(_infomap.Triple_n3_get, _infomap.Triple_n3_set)


Triple_swigregister = _infomap.Triple_swigregister
Triple_swigregister(Triple)


class Link(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(
        self, Link, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, Link, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _infomap.new_Link(*args)
        try:
            self.this.append(this)
        except Exception:
            self.this = this

    __swig_setmethods__["n1"] = _infomap.Link_n1_set
    __swig_getmethods__["n1"] = _infomap.Link_n1_get
    if _newclass:
        n1 = _swig_property(_infomap.Link_n1_get, _infomap.Link_n1_set)
    __swig_setmethods__["n2"] = _infomap.Link_n2_set
    __swig_getmethods__["n2"] = _infomap.Link_n2_get
    if _newclass:
        n2 = _swig_property(_infomap.Link_n2_get, _infomap.Link_n2_set)
    __swig_setmethods__["weight"] = _infomap.Link_weight_set
    __swig_getmethods__["weight"] = _infomap.Link_weight_get
    if _newclass:
        weight = _swig_property(_infomap.Link_weight_get,
                                _infomap.Link_weight_set)
    __swig_destroy__ = _infomap.delete_Link
    __del__ = lambda self: None


Link_swigregister = _infomap.Link_swigregister
Link_swigregister(Link)


class ComplementaryData(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(
        self, ComplementaryData, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ComplementaryData,
                                                   name)
    __repr__ = _swig_repr

    def __init__(self, n1, n2, weight):
        this = _infomap.new_ComplementaryData(n1, n2, weight)
        try:
            self.this.append(this)
        except Exception:
            self.this = this

    def addExactMatch(self, missing, weight):
        return _infomap.ComplementaryData_addExactMatch(self, missing, weight)

    def addPartialMatch(self, missing, weight):
        return _infomap.ComplementaryData_addPartialMatch(
            self, missing, weight)

    def addShiftedMatch(self, missing, weight):
        return _infomap.ComplementaryData_addShiftedMatch(
            self, missing, weight)

    __swig_setmethods__[
        "incompleteLink"] = _infomap.ComplementaryData_incompleteLink_set
    __swig_getmethods__[
        "incompleteLink"] = _infomap.ComplementaryData_incompleteLink_get
    if _newclass:
        incompleteLink = _swig_property(
            _infomap.ComplementaryData_incompleteLink_get,
            _infomap.ComplementaryData_incompleteLink_set)
    __swig_setmethods__[
        "exactMatch"] = _infomap.ComplementaryData_exactMatch_set
    __swig_getmethods__[
        "exactMatch"] = _infomap.ComplementaryData_exactMatch_get
    if _newclass:
        exactMatch = _swig_property(_infomap.ComplementaryData_exactMatch_get,
                                    _infomap.ComplementaryData_exactMatch_set)
    __swig_setmethods__[
        "sumWeightExactMatch"] = _infomap.ComplementaryData_sumWeightExactMatch_set
    __swig_getmethods__[
        "sumWeightExactMatch"] = _infomap.ComplementaryData_sumWeightExactMatch_get
    if _newclass:
        sumWeightExactMatch = _swig_property(
            _infomap.ComplementaryData_sumWeightExactMatch_get,
            _infomap.ComplementaryData_sumWeightExactMatch_set)
    __swig_setmethods__[
        "partialMatch"] = _infomap.ComplementaryData_partialMatch_set
    __swig_getmethods__[
        "partialMatch"] = _infomap.ComplementaryData_partialMatch_get
    if _newclass:
        partialMatch = _swig_property(
            _infomap.ComplementaryData_partialMatch_get,
            _infomap.ComplementaryData_partialMatch_set)
    __swig_setmethods__[
        "sumWeightPartialMatch"] = _infomap.ComplementaryData_sumWeightPartialMatch_set
    __swig_getmethods__[
        "sumWeightPartialMatch"] = _infomap.ComplementaryData_sumWeightPartialMatch_get
    if _newclass:
        sumWeightPartialMatch = _swig_property(
            _infomap.ComplementaryData_sumWeightPartialMatch_get,
            _infomap.ComplementaryData_sumWeightPartialMatch_set)
    __swig_setmethods__[
        "shiftedMatch"] = _infomap.ComplementaryData_shiftedMatch_set
    __swig_getmethods__[
        "shiftedMatch"] = _infomap.ComplementaryData_shiftedMatch_get
    if _newclass:
        shiftedMatch = _swig_property(
            _infomap.ComplementaryData_shiftedMatch_get,
            _infomap.ComplementaryData_shiftedMatch_set)
    __swig_setmethods__[
        "sumWeightShiftedMatch"] = _infomap.ComplementaryData_sumWeightShiftedMatch_set
    __swig_getmethods__[
        "sumWeightShiftedMatch"] = _infomap.ComplementaryData_sumWeightShiftedMatch_get
    if _newclass:
        sumWeightShiftedMatch = _swig_property(
            _infomap.ComplementaryData_sumWeightShiftedMatch_get,
            _infomap.ComplementaryData_sumWeightShiftedMatch_set)
    __swig_destroy__ = _infomap.delete_ComplementaryData
    __del__ = lambda self: None


ComplementaryData_swigregister = _infomap.ComplementaryData_swigregister
ComplementaryData_swigregister(ComplementaryData)


class MemNetwork(Network):
    __swig_setmethods__ = {}
    for _s in [Network]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(
        self, MemNetwork, name, value)
    __swig_getmethods__ = {}
    for _s in [Network]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, MemNetwork, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _infomap.new_MemNetwork(*args)
        try:
            self.this.append(this)
        except Exception:
            self.this = this

    __swig_destroy__ = _infomap.delete_MemNetwork
    __del__ = lambda self: None

    def readInputData(self, *args):
        return _infomap.MemNetwork_readInputData(self, *args)

    def addStateLink(self, *args):
        return _infomap.MemNetwork_addStateLink(self, *args)

    def addStateNode(self, *args):
        return _infomap.MemNetwork_addStateNode(self, *args)

    def finalizeAndCheckNetwork(self, printSummary=True):
        return _infomap.MemNetwork_finalizeAndCheckNetwork(self, printSummary)

    def printParsingResult(self, includeFirstOrderData=False):
        return _infomap.MemNetwork_printParsingResult(self,
                                                      includeFirstOrderData)

    def numStateNodes(self):
        return _infomap.MemNetwork_numStateNodes(self)

    def numPhysicalNodes(self):
        return _infomap.MemNetwork_numPhysicalNodes(self)

    def stateNodeMap(self):
        return _infomap.MemNetwork_stateNodeMap(self)

    def stateNodeWeights(self):
        return _infomap.MemNetwork_stateNodeWeights(self)

    def totalStateNodeWeight(self):
        return _infomap.MemNetwork_totalStateNodeWeight(self)

    def stateLinkMap(self):
        return _infomap.MemNetwork_stateLinkMap(self)

    def numStateLinks(self):
        return _infomap.MemNetwork_numStateLinks(self)

    def totalStateLinkWeight(self):
        return _infomap.MemNetwork_totalStateLinkWeight(self)

    def totalMemorySelfLinkWeight(self):
        return _infomap.MemNetwork_totalMemorySelfLinkWeight(self)

    def stateNodes(self):
        return _infomap.MemNetwork_stateNodes(self)

    def printNetworkAsPajek(self, filename):
        return _infomap.MemNetwork_printNetworkAsPajek(self, filename)

    def printStateNetwork(self, filename):
        return _infomap.MemNetwork_printStateNetwork(self, filename)

    def disposeLinks(self):
        return _infomap.MemNetwork_disposeLinks(self)


MemNetwork_swigregister = _infomap.MemNetwork_swigregister
MemNetwork_swigregister(MemNetwork)


class MultiplexNetwork(MemNetwork):
    __swig_setmethods__ = {}
    for _s in [MemNetwork]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(
        self, MultiplexNetwork, name, value)
    __swig_getmethods__ = {}
    for _s in [MemNetwork]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, MultiplexNetwork, name
                                                   )
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _infomap.new_MultiplexNetwork(*args)
        try:
            self.this.append(this)
        except Exception:
            self.this = this

    __swig_destroy__ = _infomap.delete_MultiplexNetwork
    __del__ = lambda self: None

    def readInputData(self, *args):
        return _infomap.MultiplexNetwork_readInputData(self, *args)

    def finalizeAndCheckNetwork(self, printSummary=True):
        return _infomap.MultiplexNetwork_finalizeAndCheckNetwork(
            self, printSummary)

    def addMultiplexLink(self, layer1, node1, layer2, node2, w):
        return _infomap.MultiplexNetwork_addMultiplexLink(
            self, layer1, node1, layer2, node2, w)

    def addMemoryNetworkFromMultiplexLinks(self):
        return _infomap.MultiplexNetwork_addMemoryNetworkFromMultiplexLinks(
            self)


MultiplexNetwork_swigregister = _infomap.MultiplexNetwork_swigregister
MultiplexNetwork_swigregister(MultiplexNetwork)

_infomap.NONE_swigconstant(_infomap)
NONE = _infomap.NONE

_infomap.PARTIAL_swigconstant(_infomap)
PARTIAL = _infomap.PARTIAL

_infomap.FULL_swigconstant(_infomap)
FULL = _infomap.FULL


class NodeData(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(
        self, NodeData, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, NodeData, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _infomap.new_NodeData(*args)
        try:
            self.this.append(this)
        except Exception:
            self.this = this

    __swig_setmethods__["flow"] = _infomap.NodeData_flow_set
    __swig_getmethods__["flow"] = _infomap.NodeData_flow_get
    if _newclass:
        flow = _swig_property(_infomap.NodeData_flow_get,
                              _infomap.NodeData_flow_set)
    __swig_setmethods__["enterFlow"] = _infomap.NodeData_enterFlow_set
    __swig_getmethods__["enterFlow"] = _infomap.NodeData_enterFlow_get
    if _newclass:
        enterFlow = _swig_property(_infomap.NodeData_enterFlow_get,
                                   _infomap.NodeData_enterFlow_set)
    __swig_setmethods__["exitFlow"] = _infomap.NodeData_exitFlow_set
    __swig_getmethods__["exitFlow"] = _infomap.NodeData_exitFlow_get
    if _newclass:
        exitFlow = _swig_property(_infomap.NodeData_exitFlow_get,
                                  _infomap.NodeData_exitFlow_set)
    __swig_setmethods__["teleportRate"] = _infomap.NodeData_teleportRate_set
    __swig_getmethods__["teleportRate"] = _infomap.NodeData_teleportRate_get
    if _newclass:
        teleportRate = _swig_property(_infomap.NodeData_teleportRate_get,
                                      _infomap.NodeData_teleportRate_set)
    __swig_setmethods__["danglingFlow"] = _infomap.NodeData_danglingFlow_set
    __swig_getmethods__["danglingFlow"] = _infomap.NodeData_danglingFlow_get
    if _newclass:
        danglingFlow = _swig_property(_infomap.NodeData_danglingFlow_get,
                                      _infomap.NodeData_danglingFlow_set)
    __swig_setmethods__[
        "indexCodelength"] = _infomap.NodeData_indexCodelength_set
    __swig_getmethods__[
        "indexCodelength"] = _infomap.NodeData_indexCodelength_get
    if _newclass:
        indexCodelength = _swig_property(_infomap.NodeData_indexCodelength_get,
                                         _infomap.NodeData_indexCodelength_set)
    __swig_setmethods__[
        "moduleCodelength"] = _infomap.NodeData_moduleCodelength_set
    __swig_getmethods__[
        "moduleCodelength"] = _infomap.NodeData_moduleCodelength_get
    if _newclass:
        moduleCodelength = _swig_property(
            _infomap.NodeData_moduleCodelength_get,
            _infomap.NodeData_moduleCodelength_set)
    __swig_setmethods__["name"] = _infomap.NodeData_name_set
    __swig_getmethods__["name"] = _infomap.NodeData_name_get
    if _newclass:
        name = _swig_property(_infomap.NodeData_name_get,
                              _infomap.NodeData_name_set)
    __swig_destroy__ = _infomap.delete_NodeData
    __del__ = lambda self: None


NodeData_swigregister = _infomap.NodeData_swigregister
NodeData_swigregister(NodeData)


class ChildEdge(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(
        self, ChildEdge, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ChildEdge, name)
    __repr__ = _swig_repr

    def __init__(self, source, target, flow):
        this = _infomap.new_ChildEdge(source, target, flow)
        try:
            self.this.append(this)
        except Exception:
            self.this = this

    __swig_setmethods__["source"] = _infomap.ChildEdge_source_set
    __swig_getmethods__["source"] = _infomap.ChildEdge_source_get
    if _newclass:
        source = _swig_property(_infomap.ChildEdge_source_get,
                                _infomap.ChildEdge_source_set)
    __swig_setmethods__["target"] = _infomap.ChildEdge_target_set
    __swig_getmethods__["target"] = _infomap.ChildEdge_target_get
    if _newclass:
        target = _swig_property(_infomap.ChildEdge_target_get,
                                _infomap.ChildEdge_target_set)
    __swig_setmethods__["flow"] = _infomap.ChildEdge_flow_set
    __swig_getmethods__["flow"] = _infomap.ChildEdge_flow_get
    if _newclass:
        flow = _swig_property(_infomap.ChildEdge_flow_get,
                              _infomap.ChildEdge_flow_set)
    __swig_destroy__ = _infomap.delete_ChildEdge
    __del__ = lambda self: None


ChildEdge_swigregister = _infomap.ChildEdge_swigregister
ChildEdge_swigregister(ChildEdge)


class EdgeComp(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(
        self, EdgeComp, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, EdgeComp, name)
    __repr__ = _swig_repr

    def __call__(self, lhs, rhs):
        return _infomap.EdgeComp___call__(self, lhs, rhs)

    def __init__(self):
        this = _infomap.new_EdgeComp()
        try:
            self.this.append(this)
        except Exception:
            self.this = this

    __swig_destroy__ = _infomap.delete_EdgeComp
    __del__ = lambda self: None


EdgeComp_swigregister = _infomap.EdgeComp_swigregister
EdgeComp_swigregister(EdgeComp)


class SNode(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(
        self, SNode, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, SNode, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _infomap.new_SNode(*args)
        try:
            self.this.append(this)
        except Exception:
            self.this = this

    __swig_destroy__ = _infomap.delete_SNode
    __del__ = lambda self: None

    def childDegree(self):
        return _infomap.SNode_childDegree(self)

    def clear(self):
        return _infomap.SNode_clear(self)

    def addChild(self, child):
        return _infomap.SNode_addChild(self, child)

    def numSerializableChildEdges(self):
        return _infomap.SNode_numSerializableChildEdges(self)

    def printState(self, indexOffset=0):
        return _infomap.SNode_printState(self, indexOffset)

    __swig_setmethods__["data"] = _infomap.SNode_data_set
    __swig_getmethods__["data"] = _infomap.SNode_data_get
    if _newclass:
        data = _swig_property(_infomap.SNode_data_get, _infomap.SNode_data_set)
    __swig_setmethods__["depth"] = _infomap.SNode_depth_set
    __swig_getmethods__["depth"] = _infomap.SNode_depth_get
    if _newclass:
        depth = _swig_property(_infomap.SNode_depth_get,
                               _infomap.SNode_depth_set)
    __swig_setmethods__["depthBelow"] = _infomap.SNode_depthBelow_set
    __swig_getmethods__["depthBelow"] = _infomap.SNode_depthBelow_get
    if _newclass:
        depthBelow = _swig_property(_infomap.SNode_depthBelow_get,
                                    _infomap.SNode_depthBelow_set)
    __swig_setmethods__["parentNode"] = _infomap.SNode_parentNode_set
    __swig_getmethods__["parentNode"] = _infomap.SNode_parentNode_get
    if _newclass:
        parentNode = _swig_property(_infomap.SNode_parentNode_get,
                                    _infomap.SNode_parentNode_set)
    __swig_setmethods__["parentIndex"] = _infomap.SNode_parentIndex_set
    __swig_getmethods__["parentIndex"] = _infomap.SNode_parentIndex_get
    if _newclass:
        parentIndex = _swig_property(_infomap.SNode_parentIndex_get,
                                     _infomap.SNode_parentIndex_set)
    __swig_setmethods__["isLeaf"] = _infomap.SNode_isLeaf_set
    __swig_getmethods__["isLeaf"] = _infomap.SNode_isLeaf_get
    if _newclass:
        isLeaf = _swig_property(_infomap.SNode_isLeaf_get,
                                _infomap.SNode_isLeaf_set)
    __swig_setmethods__[
        "originalLeafIndex"] = _infomap.SNode_originalLeafIndex_set
    __swig_getmethods__[
        "originalLeafIndex"] = _infomap.SNode_originalLeafIndex_get
    if _newclass:
        originalLeafIndex = _swig_property(
            _infomap.SNode_originalLeafIndex_get,
            _infomap.SNode_originalLeafIndex_set)
    __swig_setmethods__["id"] = _infomap.SNode_id_set
    __swig_getmethods__["id"] = _infomap.SNode_id_get
    if _newclass:
        id = _swig_property(_infomap.SNode_id_get, _infomap.SNode_id_set)
    __swig_setmethods__["children"] = _infomap.SNode_children_set
    __swig_getmethods__["children"] = _infomap.SNode_children_get
    if _newclass:
        children = _swig_property(_infomap.SNode_children_get,
                                  _infomap.SNode_children_set)
    __swig_setmethods__["childEdges"] = _infomap.SNode_childEdges_set
    __swig_getmethods__["childEdges"] = _infomap.SNode_childEdges_get
    if _newclass:
        childEdges = _swig_property(_infomap.SNode_childEdges_get,
                                    _infomap.SNode_childEdges_set)
    __swig_setmethods__["skip"] = _infomap.SNode_skip_set
    __swig_getmethods__["skip"] = _infomap.SNode_skip_get
    if _newclass:
        skip = _swig_property(_infomap.SNode_skip_get, _infomap.SNode_skip_set)
    __swig_setmethods__["isMemoryNode"] = _infomap.SNode_isMemoryNode_set
    __swig_getmethods__["isMemoryNode"] = _infomap.SNode_isMemoryNode_get
    if _newclass:
        isMemoryNode = _swig_property(_infomap.SNode_isMemoryNode_get,
                                      _infomap.SNode_isMemoryNode_set)
    __swig_setmethods__["stateIndex"] = _infomap.SNode_stateIndex_set
    __swig_getmethods__["stateIndex"] = _infomap.SNode_stateIndex_get
    if _newclass:
        stateIndex = _swig_property(_infomap.SNode_stateIndex_get,
                                    _infomap.SNode_stateIndex_set)
    __swig_setmethods__["physIndex"] = _infomap.SNode_physIndex_set
    __swig_getmethods__["physIndex"] = _infomap.SNode_physIndex_get
    if _newclass:
        physIndex = _swig_property(_infomap.SNode_physIndex_get,
                                   _infomap.SNode_physIndex_set)

    def serializationSize(self, writeEdges):
        return _infomap.SNode_serializationSize(self, writeEdges)

    def serialize(self, outFile, childPosition, writeEdges):
        return _infomap.SNode_serialize(self, outFile, childPosition,
                                        writeEdges)

    def deserialize(self, dataStream):
        return _infomap.SNode_deserialize(self, dataStream)

    def deserializeEdges(self, dataStream, directedEdges):
        return _infomap.SNode_deserializeEdges(self, dataStream, directedEdges)

    def lastChild(self):
        return _infomap.SNode_lastChild(self)

    def firstChild(self):
        return _infomap.SNode_firstChild(self)

    def nextSibling(self):
        return _infomap.SNode_nextSibling(self)

    def isLeafNode(self):
        return _infomap.SNode_isLeafNode(self)

    def isLeafModule(self):
        return _infomap.SNode_isLeafModule(self)

    def createChildEdge(self, sourceIndex, targetIndex, flow, directed):
        return _infomap.SNode_createChildEdge(self, sourceIndex, targetIndex,
                                              flow, directed)


SNode_swigregister = _infomap.SNode_swigregister
SNode_swigregister(SNode)


class LeafIterator(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(
        self, LeafIterator, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, LeafIterator, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _infomap.new_LeafIterator(*args)
        try:
            self.this.append(this)
        except Exception:
            self.this = this

    def base(self):
        return _infomap.LeafIterator_base(self)

    def isEnd(self):
        return _infomap.LeafIterator_isEnd(self)

    def __ref__(self):
        return _infomap.LeafIterator___ref__(self)

    def __deref__(self):
        return _infomap.LeafIterator___deref__(self)

    def stepForward(self):
        return _infomap.LeafIterator_stepForward(self)

    def depth(self):
        return _infomap.LeafIterator_depth(self)

    def moduleIndex(self):
        return _infomap.LeafIterator_moduleIndex(self)

    def __eq__(self, rhs):
        return _infomap.LeafIterator___eq__(self, rhs)

    def __ne__(self, rhs):
        return _infomap.LeafIterator___ne__(self, rhs)

    def __iter__(self):
        self._firstYielded = False
        return self

    def next(self):
        if not self._firstYielded:
            self._firstYielded = True
        else:
            self.stepForward()

        if self.isEnd():
            raise StopIteration

        return self

    def __next__(self):
        return self.next()

    __swig_destroy__ = _infomap.delete_LeafIterator
    __del__ = lambda self: None

    def childDegree(self):
        return _infomap.LeafIterator_childDegree(self)

    def clear(self):
        return _infomap.LeafIterator_clear(self)

    def addChild(self, child):
        return _infomap.LeafIterator_addChild(self, child)

    def numSerializableChildEdges(self):
        return _infomap.LeafIterator_numSerializableChildEdges(self)

    def printState(self, indexOffset=0):
        return _infomap.LeafIterator_printState(self, indexOffset)

    __swig_setmethods__["data"] = _infomap.LeafIterator_data_set
    __swig_getmethods__["data"] = _infomap.LeafIterator_data_get
    if _newclass:
        data = _swig_property(_infomap.LeafIterator_data_get,
                              _infomap.LeafIterator_data_set)
    __swig_setmethods__["depthBelow"] = _infomap.LeafIterator_depthBelow_set
    __swig_getmethods__["depthBelow"] = _infomap.LeafIterator_depthBelow_get
    if _newclass:
        depthBelow = _swig_property(_infomap.LeafIterator_depthBelow_get,
                                    _infomap.LeafIterator_depthBelow_set)
    __swig_setmethods__["parentNode"] = _infomap.LeafIterator_parentNode_set
    __swig_getmethods__["parentNode"] = _infomap.LeafIterator_parentNode_get
    if _newclass:
        parentNode = _swig_property(_infomap.LeafIterator_parentNode_get,
                                    _infomap.LeafIterator_parentNode_set)
    __swig_setmethods__["parentIndex"] = _infomap.LeafIterator_parentIndex_set
    __swig_getmethods__["parentIndex"] = _infomap.LeafIterator_parentIndex_get
    if _newclass:
        parentIndex = _swig_property(_infomap.LeafIterator_parentIndex_get,
                                     _infomap.LeafIterator_parentIndex_set)
    __swig_setmethods__["isLeaf"] = _infomap.LeafIterator_isLeaf_set
    __swig_getmethods__["isLeaf"] = _infomap.LeafIterator_isLeaf_get
    if _newclass:
        isLeaf = _swig_property(_infomap.LeafIterator_isLeaf_get,
                                _infomap.LeafIterator_isLeaf_set)
    __swig_setmethods__[
        "originalLeafIndex"] = _infomap.LeafIterator_originalLeafIndex_set
    __swig_getmethods__[
        "originalLeafIndex"] = _infomap.LeafIterator_originalLeafIndex_get
    if _newclass:
        originalLeafIndex = _swig_property(
            _infomap.LeafIterator_originalLeafIndex_get,
            _infomap.LeafIterator_originalLeafIndex_set)
    __swig_setmethods__["id"] = _infomap.LeafIterator_id_set
    __swig_getmethods__["id"] = _infomap.LeafIterator_id_get
    if _newclass:
        id = _swig_property(_infomap.LeafIterator_id_get,
                            _infomap.LeafIterator_id_set)
    __swig_setmethods__["children"] = _infomap.LeafIterator_children_set
    __swig_getmethods__["children"] = _infomap.LeafIterator_children_get
    if _newclass:
        children = _swig_property(_infomap.LeafIterator_children_get,
                                  _infomap.LeafIterator_children_set)
    __swig_setmethods__["childEdges"] = _infomap.LeafIterator_childEdges_set
    __swig_getmethods__["childEdges"] = _infomap.LeafIterator_childEdges_get
    if _newclass:
        childEdges = _swig_property(_infomap.LeafIterator_childEdges_get,
                                    _infomap.LeafIterator_childEdges_set)
    __swig_setmethods__["skip"] = _infomap.LeafIterator_skip_set
    __swig_getmethods__["skip"] = _infomap.LeafIterator_skip_get
    if _newclass:
        skip = _swig_property(_infomap.LeafIterator_skip_get,
                              _infomap.LeafIterator_skip_set)
    __swig_setmethods__[
        "isMemoryNode"] = _infomap.LeafIterator_isMemoryNode_set
    __swig_getmethods__[
        "isMemoryNode"] = _infomap.LeafIterator_isMemoryNode_get
    if _newclass:
        isMemoryNode = _swig_property(_infomap.LeafIterator_isMemoryNode_get,
                                      _infomap.LeafIterator_isMemoryNode_set)
    __swig_setmethods__["stateIndex"] = _infomap.LeafIterator_stateIndex_set
    __swig_getmethods__["stateIndex"] = _infomap.LeafIterator_stateIndex_get
    if _newclass:
        stateIndex = _swig_property(_infomap.LeafIterator_stateIndex_get,
                                    _infomap.LeafIterator_stateIndex_set)
    __swig_setmethods__["physIndex"] = _infomap.LeafIterator_physIndex_set
    __swig_getmethods__["physIndex"] = _infomap.LeafIterator_physIndex_get
    if _newclass:
        physIndex = _swig_property(_infomap.LeafIterator_physIndex_get,
                                   _infomap.LeafIterator_physIndex_set)

    def serializationSize(self, writeEdges):
        return _infomap.LeafIterator_serializationSize(self, writeEdges)

    def serialize(self, outFile, childPosition, writeEdges):
        return _infomap.LeafIterator_serialize(self, outFile, childPosition,
                                               writeEdges)

    def deserialize(self, dataStream):
        return _infomap.LeafIterator_deserialize(self, dataStream)

    def deserializeEdges(self, dataStream, directedEdges):
        return _infomap.LeafIterator_deserializeEdges(self, dataStream,
                                                      directedEdges)

    def lastChild(self):
        return _infomap.LeafIterator_lastChild(self)

    def firstChild(self):
        return _infomap.LeafIterator_firstChild(self)

    def nextSibling(self):
        return _infomap.LeafIterator_nextSibling(self)

    def isLeafNode(self):
        return _infomap.LeafIterator_isLeafNode(self)

    def isLeafModule(self):
        return _infomap.LeafIterator_isLeafModule(self)

    def createChildEdge(self, sourceIndex, targetIndex, flow, directed):
        return _infomap.LeafIterator_createChildEdge(self, sourceIndex,
                                                     targetIndex, flow,
                                                     directed)


LeafIterator_swigregister = _infomap.LeafIterator_swigregister
LeafIterator_swigregister(LeafIterator)


class TreeIterator(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(
        self, TreeIterator, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, TreeIterator, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _infomap.new_TreeIterator(*args)
        try:
            self.this.append(this)
        except Exception:
            self.this = this

    def base(self):
        return _infomap.TreeIterator_base(self)

    def isEnd(self):
        return _infomap.TreeIterator_isEnd(self)

    def __ref__(self):
        return _infomap.TreeIterator___ref__(self)

    def __deref__(self):
        return _infomap.TreeIterator___deref__(self)

    def stepForward(self):
        return _infomap.TreeIterator_stepForward(self)

    def depth(self):
        return _infomap.TreeIterator_depth(self)

    def moduleIndex(self):
        return _infomap.TreeIterator_moduleIndex(self)

    def path(self):
        return _infomap.TreeIterator_path(self)

    def __eq__(self, rhs):
        return _infomap.TreeIterator___eq__(self, rhs)

    def __ne__(self, rhs):
        return _infomap.TreeIterator___ne__(self, rhs)

    def __iter__(self):
        self._firstYielded = False
        return self

    def next(self):
        if not self._firstYielded:
            self._firstYielded = True
        else:
            self.stepForward()

        if self.isEnd():
            raise StopIteration

        return self

    def __next__(self):
        return self.next()

    __swig_destroy__ = _infomap.delete_TreeIterator
    __del__ = lambda self: None

    def childDegree(self):
        return _infomap.TreeIterator_childDegree(self)

    def clear(self):
        return _infomap.TreeIterator_clear(self)

    def addChild(self, child):
        return _infomap.TreeIterator_addChild(self, child)

    def numSerializableChildEdges(self):
        return _infomap.TreeIterator_numSerializableChildEdges(self)

    def printState(self, indexOffset=0):
        return _infomap.TreeIterator_printState(self, indexOffset)

    __swig_setmethods__["data"] = _infomap.TreeIterator_data_set
    __swig_getmethods__["data"] = _infomap.TreeIterator_data_get
    if _newclass:
        data = _swig_property(_infomap.TreeIterator_data_get,
                              _infomap.TreeIterator_data_set)
    __swig_setmethods__["depthBelow"] = _infomap.TreeIterator_depthBelow_set
    __swig_getmethods__["depthBelow"] = _infomap.TreeIterator_depthBelow_get
    if _newclass:
        depthBelow = _swig_property(_infomap.TreeIterator_depthBelow_get,
                                    _infomap.TreeIterator_depthBelow_set)
    __swig_setmethods__["parentNode"] = _infomap.TreeIterator_parentNode_set
    __swig_getmethods__["parentNode"] = _infomap.TreeIterator_parentNode_get
    if _newclass:
        parentNode = _swig_property(_infomap.TreeIterator_parentNode_get,
                                    _infomap.TreeIterator_parentNode_set)
    __swig_setmethods__["parentIndex"] = _infomap.TreeIterator_parentIndex_set
    __swig_getmethods__["parentIndex"] = _infomap.TreeIterator_parentIndex_get
    if _newclass:
        parentIndex = _swig_property(_infomap.TreeIterator_parentIndex_get,
                                     _infomap.TreeIterator_parentIndex_set)
    __swig_setmethods__["isLeaf"] = _infomap.TreeIterator_isLeaf_set
    __swig_getmethods__["isLeaf"] = _infomap.TreeIterator_isLeaf_get
    if _newclass:
        isLeaf = _swig_property(_infomap.TreeIterator_isLeaf_get,
                                _infomap.TreeIterator_isLeaf_set)
    __swig_setmethods__[
        "originalLeafIndex"] = _infomap.TreeIterator_originalLeafIndex_set
    __swig_getmethods__[
        "originalLeafIndex"] = _infomap.TreeIterator_originalLeafIndex_get
    if _newclass:
        originalLeafIndex = _swig_property(
            _infomap.TreeIterator_originalLeafIndex_get,
            _infomap.TreeIterator_originalLeafIndex_set)
    __swig_setmethods__["id"] = _infomap.TreeIterator_id_set
    __swig_getmethods__["id"] = _infomap.TreeIterator_id_get
    if _newclass:
        id = _swig_property(_infomap.TreeIterator_id_get,
                            _infomap.TreeIterator_id_set)
    __swig_setmethods__["children"] = _infomap.TreeIterator_children_set
    __swig_getmethods__["children"] = _infomap.TreeIterator_children_get
    if _newclass:
        children = _swig_property(_infomap.TreeIterator_children_get,
                                  _infomap.TreeIterator_children_set)
    __swig_setmethods__["childEdges"] = _infomap.TreeIterator_childEdges_set
    __swig_getmethods__["childEdges"] = _infomap.TreeIterator_childEdges_get
    if _newclass:
        childEdges = _swig_property(_infomap.TreeIterator_childEdges_get,
                                    _infomap.TreeIterator_childEdges_set)
    __swig_setmethods__["skip"] = _infomap.TreeIterator_skip_set
    __swig_getmethods__["skip"] = _infomap.TreeIterator_skip_get
    if _newclass:
        skip = _swig_property(_infomap.TreeIterator_skip_get,
                              _infomap.TreeIterator_skip_set)
    __swig_setmethods__[
        "isMemoryNode"] = _infomap.TreeIterator_isMemoryNode_set
    __swig_getmethods__[
        "isMemoryNode"] = _infomap.TreeIterator_isMemoryNode_get
    if _newclass:
        isMemoryNode = _swig_property(_infomap.TreeIterator_isMemoryNode_get,
                                      _infomap.TreeIterator_isMemoryNode_set)
    __swig_setmethods__["stateIndex"] = _infomap.TreeIterator_stateIndex_set
    __swig_getmethods__["stateIndex"] = _infomap.TreeIterator_stateIndex_get
    if _newclass:
        stateIndex = _swig_property(_infomap.TreeIterator_stateIndex_get,
                                    _infomap.TreeIterator_stateIndex_set)
    __swig_setmethods__["physIndex"] = _infomap.TreeIterator_physIndex_set
    __swig_getmethods__["physIndex"] = _infomap.TreeIterator_physIndex_get
    if _newclass:
        physIndex = _swig_property(_infomap.TreeIterator_physIndex_get,
                                   _infomap.TreeIterator_physIndex_set)

    def serializationSize(self, writeEdges):
        return _infomap.TreeIterator_serializationSize(self, writeEdges)

    def serialize(self, outFile, childPosition, writeEdges):
        return _infomap.TreeIterator_serialize(self, outFile, childPosition,
                                               writeEdges)

    def deserialize(self, dataStream):
        return _infomap.TreeIterator_deserialize(self, dataStream)

    def deserializeEdges(self, dataStream, directedEdges):
        return _infomap.TreeIterator_deserializeEdges(self, dataStream,
                                                      directedEdges)

    def lastChild(self):
        return _infomap.TreeIterator_lastChild(self)

    def firstChild(self):
        return _infomap.TreeIterator_firstChild(self)

    def nextSibling(self):
        return _infomap.TreeIterator_nextSibling(self)

    def isLeafNode(self):
        return _infomap.TreeIterator_isLeafNode(self)

    def isLeafModule(self):
        return _infomap.TreeIterator_isLeafModule(self)

    def createChildEdge(self, sourceIndex, targetIndex, flow, directed):
        return _infomap.TreeIterator_createChildEdge(self, sourceIndex,
                                                     targetIndex, flow,
                                                     directed)


TreeIterator_swigregister = _infomap.TreeIterator_swigregister
TreeIterator_swigregister(TreeIterator)


class ChildIterator(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(
        self, ChildIterator, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ChildIterator, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _infomap.new_ChildIterator(*args)
        try:
            self.this.append(this)
        except Exception:
            self.this = this

    def base(self):
        return _infomap.ChildIterator_base(self)

    def isEnd(self):
        return _infomap.ChildIterator_isEnd(self)

    def __ref__(self):
        return _infomap.ChildIterator___ref__(self)

    def __deref__(self):
        return _infomap.ChildIterator___deref__(self)

    def stepForward(self):
        return _infomap.ChildIterator_stepForward(self)

    def childIndex(self):
        return _infomap.ChildIterator_childIndex(self)

    def __eq__(self, rhs):
        return _infomap.ChildIterator___eq__(self, rhs)

    def __ne__(self, rhs):
        return _infomap.ChildIterator___ne__(self, rhs)

    __swig_destroy__ = _infomap.delete_ChildIterator
    __del__ = lambda self: None

    def childDegree(self):
        return _infomap.ChildIterator_childDegree(self)

    def clear(self):
        return _infomap.ChildIterator_clear(self)

    def addChild(self, child):
        return _infomap.ChildIterator_addChild(self, child)

    def numSerializableChildEdges(self):
        return _infomap.ChildIterator_numSerializableChildEdges(self)

    def printState(self, indexOffset=0):
        return _infomap.ChildIterator_printState(self, indexOffset)

    __swig_setmethods__["data"] = _infomap.ChildIterator_data_set
    __swig_getmethods__["data"] = _infomap.ChildIterator_data_get
    if _newclass:
        data = _swig_property(_infomap.ChildIterator_data_get,
                              _infomap.ChildIterator_data_set)
    __swig_setmethods__["depth"] = _infomap.ChildIterator_depth_set
    __swig_getmethods__["depth"] = _infomap.ChildIterator_depth_get
    if _newclass:
        depth = _swig_property(_infomap.ChildIterator_depth_get,
                               _infomap.ChildIterator_depth_set)
    __swig_setmethods__["depthBelow"] = _infomap.ChildIterator_depthBelow_set
    __swig_getmethods__["depthBelow"] = _infomap.ChildIterator_depthBelow_get
    if _newclass:
        depthBelow = _swig_property(_infomap.ChildIterator_depthBelow_get,
                                    _infomap.ChildIterator_depthBelow_set)
    __swig_setmethods__["parentNode"] = _infomap.ChildIterator_parentNode_set
    __swig_getmethods__["parentNode"] = _infomap.ChildIterator_parentNode_get
    if _newclass:
        parentNode = _swig_property(_infomap.ChildIterator_parentNode_get,
                                    _infomap.ChildIterator_parentNode_set)
    __swig_setmethods__["parentIndex"] = _infomap.ChildIterator_parentIndex_set
    __swig_getmethods__["parentIndex"] = _infomap.ChildIterator_parentIndex_get
    if _newclass:
        parentIndex = _swig_property(_infomap.ChildIterator_parentIndex_get,
                                     _infomap.ChildIterator_parentIndex_set)
    __swig_setmethods__["isLeaf"] = _infomap.ChildIterator_isLeaf_set
    __swig_getmethods__["isLeaf"] = _infomap.ChildIterator_isLeaf_get
    if _newclass:
        isLeaf = _swig_property(_infomap.ChildIterator_isLeaf_get,
                                _infomap.ChildIterator_isLeaf_set)
    __swig_setmethods__[
        "originalLeafIndex"] = _infomap.ChildIterator_originalLeafIndex_set
    __swig_getmethods__[
        "originalLeafIndex"] = _infomap.ChildIterator_originalLeafIndex_get
    if _newclass:
        originalLeafIndex = _swig_property(
            _infomap.ChildIterator_originalLeafIndex_get,
            _infomap.ChildIterator_originalLeafIndex_set)
    __swig_setmethods__["id"] = _infomap.ChildIterator_id_set
    __swig_getmethods__["id"] = _infomap.ChildIterator_id_get
    if _newclass:
        id = _swig_property(_infomap.ChildIterator_id_get,
                            _infomap.ChildIterator_id_set)
    __swig_setmethods__["children"] = _infomap.ChildIterator_children_set
    __swig_getmethods__["children"] = _infomap.ChildIterator_children_get
    if _newclass:
        children = _swig_property(_infomap.ChildIterator_children_get,
                                  _infomap.ChildIterator_children_set)
    __swig_setmethods__["childEdges"] = _infomap.ChildIterator_childEdges_set
    __swig_getmethods__["childEdges"] = _infomap.ChildIterator_childEdges_get
    if _newclass:
        childEdges = _swig_property(_infomap.ChildIterator_childEdges_get,
                                    _infomap.ChildIterator_childEdges_set)
    __swig_setmethods__["skip"] = _infomap.ChildIterator_skip_set
    __swig_getmethods__["skip"] = _infomap.ChildIterator_skip_get
    if _newclass:
        skip = _swig_property(_infomap.ChildIterator_skip_get,
                              _infomap.ChildIterator_skip_set)
    __swig_setmethods__[
        "isMemoryNode"] = _infomap.ChildIterator_isMemoryNode_set
    __swig_getmethods__[
        "isMemoryNode"] = _infomap.ChildIterator_isMemoryNode_get
    if _newclass:
        isMemoryNode = _swig_property(_infomap.ChildIterator_isMemoryNode_get,
                                      _infomap.ChildIterator_isMemoryNode_set)
    __swig_setmethods__["stateIndex"] = _infomap.ChildIterator_stateIndex_set
    __swig_getmethods__["stateIndex"] = _infomap.ChildIterator_stateIndex_get
    if _newclass:
        stateIndex = _swig_property(_infomap.ChildIterator_stateIndex_get,
                                    _infomap.ChildIterator_stateIndex_set)
    __swig_setmethods__["physIndex"] = _infomap.ChildIterator_physIndex_set
    __swig_getmethods__["physIndex"] = _infomap.ChildIterator_physIndex_get
    if _newclass:
        physIndex = _swig_property(_infomap.ChildIterator_physIndex_get,
                                   _infomap.ChildIterator_physIndex_set)

    def serializationSize(self, writeEdges):
        return _infomap.ChildIterator_serializationSize(self, writeEdges)

    def serialize(self, outFile, childPosition, writeEdges):
        return _infomap.ChildIterator_serialize(self, outFile, childPosition,
                                                writeEdges)

    def deserialize(self, dataStream):
        return _infomap.ChildIterator_deserialize(self, dataStream)

    def deserializeEdges(self, dataStream, directedEdges):
        return _infomap.ChildIterator_deserializeEdges(self, dataStream,
                                                       directedEdges)

    def lastChild(self):
        return _infomap.ChildIterator_lastChild(self)

    def firstChild(self):
        return _infomap.ChildIterator_firstChild(self)

    def nextSibling(self):
        return _infomap.ChildIterator_nextSibling(self)

    def isLeafNode(self):
        return _infomap.ChildIterator_isLeafNode(self)

    def isLeafModule(self):
        return _infomap.ChildIterator_isLeafModule(self)

    def createChildEdge(self, sourceIndex, targetIndex, flow, directed):
        return _infomap.ChildIterator_createChildEdge(self, sourceIndex,
                                                      targetIndex, flow,
                                                      directed)


ChildIterator_swigregister = _infomap.ChildIterator_swigregister
ChildIterator_swigregister(ChildIterator)


class HierarchicalNetwork(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(
        self, HierarchicalNetwork, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, HierarchicalNetwork,
                                                   name)
    __repr__ = _swig_repr

    def __init__(self, conf):
        this = _infomap.new_HierarchicalNetwork(conf)
        try:
            self.this.append(this)
        except Exception:
            self.this = this

    __swig_destroy__ = _infomap.delete_HierarchicalNetwork
    __del__ = lambda self: None

    def init(self, networkName, codelength, oneLevelCodelength):
        return _infomap.HierarchicalNetwork_init(self, networkName, codelength,
                                                 oneLevelCodelength)

    def clear(self, *args):
        return _infomap.HierarchicalNetwork_clear(self, *args)

    def getRootNode(self):
        return _infomap.HierarchicalNetwork_getRootNode(self)

    def numTopModules(self):
        return _infomap.HierarchicalNetwork_numTopModules(self)

    def leafIter(self, moduleIndexDepth=-1):
        return _infomap.HierarchicalNetwork_leafIter(self, moduleIndexDepth)

    def treeIter(self, moduleIndexDepth=-1):
        return _infomap.HierarchicalNetwork_treeIter(self, moduleIndexDepth)

    def addNode(self, parent, flow, exitFlow):
        return _infomap.HierarchicalNetwork_addNode(self, parent, flow,
                                                    exitFlow)

    def addLeafNode(self, *args):
        return _infomap.HierarchicalNetwork_addLeafNode(self, *args)

    def prepareAddLeafNodes(self, numLeafNodes):
        return _infomap.HierarchicalNetwork_prepareAddLeafNodes(
            self, numLeafNodes)

    def addLeafEdge(self, sourceLeafNodeIndex, targetLeafNodeIndex, flow):
        return _infomap.HierarchicalNetwork_addLeafEdge(
            self, sourceLeafNodeIndex, targetLeafNodeIndex, flow)

    def propagateNodeNameUpInHierarchy(self, node):
        return _infomap.HierarchicalNetwork_propagateNodeNameUpInHierarchy(
            self, node)

    def writeStreamableTree(self, fileName, writeEdges):
        return _infomap.HierarchicalNetwork_writeStreamableTree(
            self, fileName, writeEdges)

    def readStreamableTree(self, fileName):
        return _infomap.HierarchicalNetwork_readStreamableTree(self, fileName)

    def writeHumanReadableTree(self,
                               fileName,
                               writeHierarchicalNetworkEdges=False):
        return _infomap.HierarchicalNetwork_writeHumanReadableTree(
            self, fileName, writeHierarchicalNetworkEdges)

    def writeClu(self, fileName, moduleIndexDepth=1):
        return _infomap.HierarchicalNetwork_writeClu(self, fileName,
                                                     moduleIndexDepth)

    def readHumanReadableTree(self, fileName):
        return _infomap.HierarchicalNetwork_readHumanReadableTree(
            self, fileName)

    def writeMap(self, fileName):
        return _infomap.HierarchicalNetwork_writeMap(self, fileName)

    def numLeafNodes(self):
        return _infomap.HierarchicalNetwork_numLeafNodes(self)

    def numLeafEdges(self):
        return _infomap.HierarchicalNetwork_numLeafEdges(self)

    def numNodesInTree(self):
        return _infomap.HierarchicalNetwork_numNodesInTree(self)

    def maxDepth(self):
        return _infomap.HierarchicalNetwork_maxDepth(self)

    def codelength(self):
        return _infomap.HierarchicalNetwork_codelength(self)

    def onelevelCodelength(self):
        return _infomap.HierarchicalNetwork_onelevelCodelength(self)


HierarchicalNetwork_swigregister = _infomap.HierarchicalNetwork_swigregister
HierarchicalNetwork_swigregister(HierarchicalNetwork)

# This file is compatible with both classic and new-style classes.
