# 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.


