# This file was automatically generated by SWIG (https://www.swig.org).
# Version 4.2.1
#
# 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 as _swig_python_version_info
# Import the low-level C/C++ module
if __package__ or "." in __name__:
    from . import _Sword
else:
    import _Sword

try:
    import builtins as __builtin__
except ImportError:
    import __builtin__

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


def _swig_setattr_nondynamic_instance_variable(set):
    def set_instance_attr(self, name, value):
        if name == "this":
            set(self, name, value)
        elif name == "thisown":
            self.this.own(value)
        elif hasattr(self, name) and isinstance(getattr(type(self), name), property):
            set(self, name, value)
        else:
            raise AttributeError("You cannot add instance attributes to %s" % self)
    return set_instance_attr


def _swig_setattr_nondynamic_class_variable(set):
    def set_class_attr(cls, name, value):
        if hasattr(cls, name) and not isinstance(getattr(cls, name), property):
            set(cls, name, value)
        else:
            raise AttributeError("You cannot add class attributes to %s" % cls)
    return set_class_attr


def _swig_add_metaclass(metaclass):
    """Class decorator for adding a metaclass to a SWIG wrapped class - a slimmed down version of six.add_metaclass"""
    def wrapper(cls):
        return metaclass(cls.__name__, cls.__bases__, cls.__dict__.copy())
    return wrapper


class _SwigNonDynamicMeta(type):
    """Meta class to enforce nondynamic attributes (no new attributes) for a class"""
    __setattr__ = _swig_setattr_nondynamic_class_variable(type.__setattr__)


import weakref

JUNKBUFSIZE = _Sword.JUNKBUFSIZE
class SWBuf(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    nullStr = property(_Sword.SWBuf_nullStr_get, _Sword.SWBuf_nullStr_set)

    def __init__(self, initVal, initSize=0):
        _Sword.SWBuf_swiginit(self, _Sword.new_SWBuf(initVal, initSize))
    __swig_destroy__ = _Sword.delete_SWBuf

    def setFillByte(self, ch):
        return _Sword.SWBuf_setFillByte(self, ch)

    def getFillByte(self):
        return _Sword.SWBuf_getFillByte(self)

    def c_str(self):
        return _Sword.SWBuf_c_str(self)

    def charAtGuarded(self, pos):
        return _Sword.SWBuf_charAtGuarded(self, pos)

    def charAt(self, pos):
        return _Sword.SWBuf_charAt(self, pos)

    def size(self, *args):
        return _Sword.SWBuf_size(self, *args)

    def length(self):
        return _Sword.SWBuf_length(self)

    def set(self, *args):
        return _Sword.SWBuf_set(self, *args)

    def setFormatted(self, format):
        return _Sword.SWBuf_setFormatted(self, format)

    def setSize(self, len):
        return _Sword.SWBuf_setSize(self, len)

    def resize(self, len):
        return _Sword.SWBuf_resize(self, len)

    def append(self, *args):
        return _Sword.SWBuf_append(self, *args)

    def appendFormatted(self, format):
        return _Sword.SWBuf_appendFormatted(self, format)

    def insert(self, *args):
        return _Sword.SWBuf_insert(self, *args)

    def getRawData(self):
        return _Sword.SWBuf_getRawData(self)

    def __str__(self):
        return _Sword.SWBuf___str__(self)

    def trimStart(self):
        return _Sword.SWBuf_trimStart(self)

    def trimEnd(self):
        return _Sword.SWBuf_trimEnd(self)

    def trim(self):
        return _Sword.SWBuf_trim(self)

    def stripPrefix(self, separator, endOfStringAsSeparator=False):
        return _Sword.SWBuf_stripPrefix(self, separator, endOfStringAsSeparator)

    def replaceBytes(self, targets, newByte):
        return _Sword.SWBuf_replaceBytes(self, targets, newByte)

    def toUpper(self):
        return _Sword.SWBuf_toUpper(self)

    def toLower(self):
        return _Sword.SWBuf_toLower(self)

    def indexOf(self, needle):
        return _Sword.SWBuf_indexOf(self, needle)

    def startsWith(self, *args):
        return _Sword.SWBuf_startsWith(self, *args)

    def endsWith(self, *args):
        return _Sword.SWBuf_endsWith(self, *args)

    def compare(self, *args):
        return _Sword.SWBuf_compare(self, *args)

    def charAt2(self, pos):
        return _Sword.SWBuf_charAt2(self, pos)

# Register SWBuf in _Sword:
_Sword.SWBuf_swigregister(SWBuf)
cvar = _Sword.cvar

class SwigPyIterator(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr
    __swig_destroy__ = _Sword.delete_SwigPyIterator

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

# Register SwigPyIterator in _Sword:
_Sword.SwigPyIterator_swigregister(SwigPyIterator)
class AttributeValueMap(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

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

    def __nonzero__(self):
        return _Sword.AttributeValueMap___nonzero__(self)

    def __bool__(self):
        return _Sword.AttributeValueMap___bool__(self)

    def __len__(self):
        return _Sword.AttributeValueMap___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 _Sword.AttributeValueMap___getitem__(self, key)

    def __delitem__(self, key):
        return _Sword.AttributeValueMap___delitem__(self, key)

    def has_key(self, key):
        return _Sword.AttributeValueMap_has_key(self, key)

    def keys(self):
        return _Sword.AttributeValueMap_keys(self)

    def values(self):
        return _Sword.AttributeValueMap_values(self)

    def items(self):
        return _Sword.AttributeValueMap_items(self)

    def __contains__(self, key):
        return _Sword.AttributeValueMap___contains__(self, key)

    def key_iterator(self):
        return _Sword.AttributeValueMap_key_iterator(self)

    def value_iterator(self):
        return _Sword.AttributeValueMap_value_iterator(self)

    def __setitem__(self, *args):
        return _Sword.AttributeValueMap___setitem__(self, *args)

    def asdict(self):
        return _Sword.AttributeValueMap_asdict(self)

    def __init__(self, *args):
        _Sword.AttributeValueMap_swiginit(self, _Sword.new_AttributeValueMap(*args))

    def empty(self):
        return _Sword.AttributeValueMap_empty(self)

    def size(self):
        return _Sword.AttributeValueMap_size(self)

    def swap(self, v):
        return _Sword.AttributeValueMap_swap(self, v)

    def begin(self):
        return _Sword.AttributeValueMap_begin(self)

    def end(self):
        return _Sword.AttributeValueMap_end(self)

    def rbegin(self):
        return _Sword.AttributeValueMap_rbegin(self)

    def rend(self):
        return _Sword.AttributeValueMap_rend(self)

    def clear(self):
        return _Sword.AttributeValueMap_clear(self)

    def get_allocator(self):
        return _Sword.AttributeValueMap_get_allocator(self)

    def count(self, x):
        return _Sword.AttributeValueMap_count(self, x)

    def erase(self, *args):
        return _Sword.AttributeValueMap_erase(self, *args)

    def find(self, x):
        return _Sword.AttributeValueMap_find(self, x)

    def lower_bound(self, x):
        return _Sword.AttributeValueMap_lower_bound(self, x)

    def upper_bound(self, x):
        return _Sword.AttributeValueMap_upper_bound(self, x)
    __swig_destroy__ = _Sword.delete_AttributeValueMap

# Register AttributeValueMap in _Sword:
_Sword.AttributeValueMap_swigregister(AttributeValueMap)
class AttributeListMap(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

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

    def __nonzero__(self):
        return _Sword.AttributeListMap___nonzero__(self)

    def __bool__(self):
        return _Sword.AttributeListMap___bool__(self)

    def __len__(self):
        return _Sword.AttributeListMap___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 _Sword.AttributeListMap___getitem__(self, key)

    def __delitem__(self, key):
        return _Sword.AttributeListMap___delitem__(self, key)

    def has_key(self, key):
        return _Sword.AttributeListMap_has_key(self, key)

    def keys(self):
        return _Sword.AttributeListMap_keys(self)

    def values(self):
        return _Sword.AttributeListMap_values(self)

    def items(self):
        return _Sword.AttributeListMap_items(self)

    def __contains__(self, key):
        return _Sword.AttributeListMap___contains__(self, key)

    def key_iterator(self):
        return _Sword.AttributeListMap_key_iterator(self)

    def value_iterator(self):
        return _Sword.AttributeListMap_value_iterator(self)

    def __setitem__(self, *args):
        return _Sword.AttributeListMap___setitem__(self, *args)

    def asdict(self):
        return _Sword.AttributeListMap_asdict(self)

    def __init__(self, *args):
        _Sword.AttributeListMap_swiginit(self, _Sword.new_AttributeListMap(*args))

    def empty(self):
        return _Sword.AttributeListMap_empty(self)

    def size(self):
        return _Sword.AttributeListMap_size(self)

    def swap(self, v):
        return _Sword.AttributeListMap_swap(self, v)

    def begin(self):
        return _Sword.AttributeListMap_begin(self)

    def end(self):
        return _Sword.AttributeListMap_end(self)

    def rbegin(self):
        return _Sword.AttributeListMap_rbegin(self)

    def rend(self):
        return _Sword.AttributeListMap_rend(self)

    def clear(self):
        return _Sword.AttributeListMap_clear(self)

    def get_allocator(self):
        return _Sword.AttributeListMap_get_allocator(self)

    def count(self, x):
        return _Sword.AttributeListMap_count(self, x)

    def erase(self, *args):
        return _Sword.AttributeListMap_erase(self, *args)

    def find(self, x):
        return _Sword.AttributeListMap_find(self, x)

    def lower_bound(self, x):
        return _Sword.AttributeListMap_lower_bound(self, x)

    def upper_bound(self, x):
        return _Sword.AttributeListMap_upper_bound(self, x)
    __swig_destroy__ = _Sword.delete_AttributeListMap

# Register AttributeListMap in _Sword:
_Sword.AttributeListMap_swigregister(AttributeListMap)
class AttributeTypeListMap(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

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

    def __nonzero__(self):
        return _Sword.AttributeTypeListMap___nonzero__(self)

    def __bool__(self):
        return _Sword.AttributeTypeListMap___bool__(self)

    def __len__(self):
        return _Sword.AttributeTypeListMap___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 _Sword.AttributeTypeListMap___getitem__(self, key)

    def __delitem__(self, key):
        return _Sword.AttributeTypeListMap___delitem__(self, key)

    def has_key(self, key):
        return _Sword.AttributeTypeListMap_has_key(self, key)

    def keys(self):
        return _Sword.AttributeTypeListMap_keys(self)

    def values(self):
        return _Sword.AttributeTypeListMap_values(self)

    def items(self):
        return _Sword.AttributeTypeListMap_items(self)

    def __contains__(self, key):
        return _Sword.AttributeTypeListMap___contains__(self, key)

    def key_iterator(self):
        return _Sword.AttributeTypeListMap_key_iterator(self)

    def value_iterator(self):
        return _Sword.AttributeTypeListMap_value_iterator(self)

    def __setitem__(self, *args):
        return _Sword.AttributeTypeListMap___setitem__(self, *args)

    def asdict(self):
        return _Sword.AttributeTypeListMap_asdict(self)

    def __init__(self, *args):
        _Sword.AttributeTypeListMap_swiginit(self, _Sword.new_AttributeTypeListMap(*args))

    def empty(self):
        return _Sword.AttributeTypeListMap_empty(self)

    def size(self):
        return _Sword.AttributeTypeListMap_size(self)

    def swap(self, v):
        return _Sword.AttributeTypeListMap_swap(self, v)

    def begin(self):
        return _Sword.AttributeTypeListMap_begin(self)

    def end(self):
        return _Sword.AttributeTypeListMap_end(self)

    def rbegin(self):
        return _Sword.AttributeTypeListMap_rbegin(self)

    def rend(self):
        return _Sword.AttributeTypeListMap_rend(self)

    def clear(self):
        return _Sword.AttributeTypeListMap_clear(self)

    def get_allocator(self):
        return _Sword.AttributeTypeListMap_get_allocator(self)

    def count(self, x):
        return _Sword.AttributeTypeListMap_count(self, x)

    def erase(self, *args):
        return _Sword.AttributeTypeListMap_erase(self, *args)

    def find(self, x):
        return _Sword.AttributeTypeListMap_find(self, x)

    def lower_bound(self, x):
        return _Sword.AttributeTypeListMap_lower_bound(self, x)

    def upper_bound(self, x):
        return _Sword.AttributeTypeListMap_upper_bound(self, x)
    __swig_destroy__ = _Sword.delete_AttributeTypeListMap

# Register AttributeTypeListMap in _Sword:
_Sword.AttributeTypeListMap_swigregister(AttributeTypeListMap)
class PyConfigEntMap(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

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

    def __nonzero__(self):
        return _Sword.PyConfigEntMap___nonzero__(self)

    def __bool__(self):
        return _Sword.PyConfigEntMap___bool__(self)

    def __len__(self):
        return _Sword.PyConfigEntMap___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 _Sword.PyConfigEntMap___getitem__(self, key)

    def __delitem__(self, key):
        return _Sword.PyConfigEntMap___delitem__(self, key)

    def has_key(self, key):
        return _Sword.PyConfigEntMap_has_key(self, key)

    def keys(self):
        return _Sword.PyConfigEntMap_keys(self)

    def values(self):
        return _Sword.PyConfigEntMap_values(self)

    def items(self):
        return _Sword.PyConfigEntMap_items(self)

    def __contains__(self, key):
        return _Sword.PyConfigEntMap___contains__(self, key)

    def key_iterator(self):
        return _Sword.PyConfigEntMap_key_iterator(self)

    def value_iterator(self):
        return _Sword.PyConfigEntMap_value_iterator(self)

    def __setitem__(self, *args):
        return _Sword.PyConfigEntMap___setitem__(self, *args)

    def __init__(self, *args):
        _Sword.PyConfigEntMap_swiginit(self, _Sword.new_PyConfigEntMap(*args))

    def empty(self):
        return _Sword.PyConfigEntMap_empty(self)

    def size(self):
        return _Sword.PyConfigEntMap_size(self)

    def swap(self, v):
        return _Sword.PyConfigEntMap_swap(self, v)

    def begin(self):
        return _Sword.PyConfigEntMap_begin(self)

    def end(self):
        return _Sword.PyConfigEntMap_end(self)

    def rbegin(self):
        return _Sword.PyConfigEntMap_rbegin(self)

    def rend(self):
        return _Sword.PyConfigEntMap_rend(self)

    def clear(self):
        return _Sword.PyConfigEntMap_clear(self)

    def get_allocator(self):
        return _Sword.PyConfigEntMap_get_allocator(self)

    def count(self, x):
        return _Sword.PyConfigEntMap_count(self, x)

    def erase(self, *args):
        return _Sword.PyConfigEntMap_erase(self, *args)

    def find(self, x):
        return _Sword.PyConfigEntMap_find(self, x)

    def lower_bound(self, x):
        return _Sword.PyConfigEntMap_lower_bound(self, x)

    def upper_bound(self, x):
        return _Sword.PyConfigEntMap_upper_bound(self, x)

    def equal_range(self, *args):
        return _Sword.PyConfigEntMap_equal_range(self, *args)
    __swig_destroy__ = _Sword.delete_PyConfigEntMap

# Register PyConfigEntMap in _Sword:
_Sword.PyConfigEntMap_swigregister(PyConfigEntMap)
class PySectionMap(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

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

    def __nonzero__(self):
        return _Sword.PySectionMap___nonzero__(self)

    def __bool__(self):
        return _Sword.PySectionMap___bool__(self)

    def __len__(self):
        return _Sword.PySectionMap___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 _Sword.PySectionMap___getitem__(self, key)

    def __delitem__(self, key):
        return _Sword.PySectionMap___delitem__(self, key)

    def has_key(self, key):
        return _Sword.PySectionMap_has_key(self, key)

    def keys(self):
        return _Sword.PySectionMap_keys(self)

    def values(self):
        return _Sword.PySectionMap_values(self)

    def items(self):
        return _Sword.PySectionMap_items(self)

    def __contains__(self, key):
        return _Sword.PySectionMap___contains__(self, key)

    def key_iterator(self):
        return _Sword.PySectionMap_key_iterator(self)

    def value_iterator(self):
        return _Sword.PySectionMap_value_iterator(self)

    def __setitem__(self, *args):
        return _Sword.PySectionMap___setitem__(self, *args)

    def asdict(self):
        return _Sword.PySectionMap_asdict(self)

    def __init__(self, *args):
        _Sword.PySectionMap_swiginit(self, _Sword.new_PySectionMap(*args))

    def empty(self):
        return _Sword.PySectionMap_empty(self)

    def size(self):
        return _Sword.PySectionMap_size(self)

    def swap(self, v):
        return _Sword.PySectionMap_swap(self, v)

    def begin(self):
        return _Sword.PySectionMap_begin(self)

    def end(self):
        return _Sword.PySectionMap_end(self)

    def rbegin(self):
        return _Sword.PySectionMap_rbegin(self)

    def rend(self):
        return _Sword.PySectionMap_rend(self)

    def clear(self):
        return _Sword.PySectionMap_clear(self)

    def get_allocator(self):
        return _Sword.PySectionMap_get_allocator(self)

    def count(self, x):
        return _Sword.PySectionMap_count(self, x)

    def erase(self, *args):
        return _Sword.PySectionMap_erase(self, *args)

    def find(self, x):
        return _Sword.PySectionMap_find(self, x)

    def lower_bound(self, x):
        return _Sword.PySectionMap_lower_bound(self, x)

    def upper_bound(self, x):
        return _Sword.PySectionMap_upper_bound(self, x)
    __swig_destroy__ = _Sword.delete_PySectionMap

# Register PySectionMap in _Sword:
_Sword.PySectionMap_swigregister(PySectionMap)
class ModuleMap(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

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

    def __nonzero__(self):
        return _Sword.ModuleMap___nonzero__(self)

    def __bool__(self):
        return _Sword.ModuleMap___bool__(self)

    def __len__(self):
        return _Sword.ModuleMap___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 _Sword.ModuleMap___getitem__(self, key)

    def __delitem__(self, key):
        return _Sword.ModuleMap___delitem__(self, key)

    def has_key(self, key):
        return _Sword.ModuleMap_has_key(self, key)

    def keys(self):
        return _Sword.ModuleMap_keys(self)

    def values(self):
        return _Sword.ModuleMap_values(self)

    def items(self):
        return _Sword.ModuleMap_items(self)

    def __contains__(self, key):
        return _Sword.ModuleMap___contains__(self, key)

    def key_iterator(self):
        return _Sword.ModuleMap_key_iterator(self)

    def value_iterator(self):
        return _Sword.ModuleMap_value_iterator(self)

    def __setitem__(self, *args):
        return _Sword.ModuleMap___setitem__(self, *args)

    def asdict(self):
        return _Sword.ModuleMap_asdict(self)

    def __init__(self, *args):
        _Sword.ModuleMap_swiginit(self, _Sword.new_ModuleMap(*args))

    def empty(self):
        return _Sword.ModuleMap_empty(self)

    def size(self):
        return _Sword.ModuleMap_size(self)

    def swap(self, v):
        return _Sword.ModuleMap_swap(self, v)

    def begin(self):
        return _Sword.ModuleMap_begin(self)

    def end(self):
        return _Sword.ModuleMap_end(self)

    def rbegin(self):
        return _Sword.ModuleMap_rbegin(self)

    def rend(self):
        return _Sword.ModuleMap_rend(self)

    def clear(self):
        return _Sword.ModuleMap_clear(self)

    def get_allocator(self):
        return _Sword.ModuleMap_get_allocator(self)

    def count(self, x):
        return _Sword.ModuleMap_count(self, x)

    def erase(self, *args):
        return _Sword.ModuleMap_erase(self, *args)

    def find(self, x):
        return _Sword.ModuleMap_find(self, x)

    def lower_bound(self, x):
        return _Sword.ModuleMap_lower_bound(self, x)

    def upper_bound(self, x):
        return _Sword.ModuleMap_upper_bound(self, x)
    __swig_destroy__ = _Sword.delete_ModuleMap

# Register ModuleMap in _Sword:
_Sword.ModuleMap_swigregister(ModuleMap)
class StringVector(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    def __init__(self, *args):
        _Sword.StringVector_swiginit(self, _Sword.new_StringVector(*args))

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

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

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

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

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

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

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

    def capacity(self):
        return _Sword.StringVector_capacity(self)
    __swig_destroy__ = _Sword.delete_StringVector

# Register StringVector in _Sword:
_Sword.StringVector_swigregister(StringVector)
class StringList(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

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

    def __nonzero__(self):
        return _Sword.StringList___nonzero__(self)

    def __bool__(self):
        return _Sword.StringList___bool__(self)

    def __len__(self):
        return _Sword.StringList___len__(self)

    def __getslice__(self, i, j):
        return _Sword.StringList___getslice__(self, i, j)

    def __setslice__(self, *args):
        return _Sword.StringList___setslice__(self, *args)

    def __delslice__(self, i, j):
        return _Sword.StringList___delslice__(self, i, j)

    def __delitem__(self, *args):
        return _Sword.StringList___delitem__(self, *args)

    def __getitem__(self, *args):
        return _Sword.StringList___getitem__(self, *args)

    def __setitem__(self, *args):
        return _Sword.StringList___setitem__(self, *args)

    def pop(self):
        return _Sword.StringList_pop(self)

    def append(self, x):
        return _Sword.StringList_append(self, x)

    def empty(self):
        return _Sword.StringList_empty(self)

    def size(self):
        return _Sword.StringList_size(self)

    def swap(self, v):
        return _Sword.StringList_swap(self, v)

    def begin(self):
        return _Sword.StringList_begin(self)

    def end(self):
        return _Sword.StringList_end(self)

    def rbegin(self):
        return _Sword.StringList_rbegin(self)

    def rend(self):
        return _Sword.StringList_rend(self)

    def clear(self):
        return _Sword.StringList_clear(self)

    def get_allocator(self):
        return _Sword.StringList_get_allocator(self)

    def pop_back(self):
        return _Sword.StringList_pop_back(self)

    def erase(self, *args):
        return _Sword.StringList_erase(self, *args)

    def __init__(self, *args):
        _Sword.StringList_swiginit(self, _Sword.new_StringList(*args))

    def push_back(self, x):
        return _Sword.StringList_push_back(self, x)

    def front(self):
        return _Sword.StringList_front(self)

    def back(self):
        return _Sword.StringList_back(self)

    def assign(self, n, x):
        return _Sword.StringList_assign(self, n, x)

    def resize(self, *args):
        return _Sword.StringList_resize(self, *args)

    def insert(self, *args):
        return _Sword.StringList_insert(self, *args)

    def pop_front(self):
        return _Sword.StringList_pop_front(self)

    def push_front(self, x):
        return _Sword.StringList_push_front(self, x)

    def reverse(self):
        return _Sword.StringList_reverse(self)
    __swig_destroy__ = _Sword.delete_StringList

# Register StringList in _Sword:
_Sword.StringList_swigregister(StringList)
class InstallSourceMap(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

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

    def __nonzero__(self):
        return _Sword.InstallSourceMap___nonzero__(self)

    def __bool__(self):
        return _Sword.InstallSourceMap___bool__(self)

    def __len__(self):
        return _Sword.InstallSourceMap___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 _Sword.InstallSourceMap___getitem__(self, key)

    def __delitem__(self, key):
        return _Sword.InstallSourceMap___delitem__(self, key)

    def has_key(self, key):
        return _Sword.InstallSourceMap_has_key(self, key)

    def keys(self):
        return _Sword.InstallSourceMap_keys(self)

    def values(self):
        return _Sword.InstallSourceMap_values(self)

    def items(self):
        return _Sword.InstallSourceMap_items(self)

    def __contains__(self, key):
        return _Sword.InstallSourceMap___contains__(self, key)

    def key_iterator(self):
        return _Sword.InstallSourceMap_key_iterator(self)

    def value_iterator(self):
        return _Sword.InstallSourceMap_value_iterator(self)

    def __setitem__(self, *args):
        return _Sword.InstallSourceMap___setitem__(self, *args)

    def asdict(self):
        return _Sword.InstallSourceMap_asdict(self)

    def __init__(self, *args):
        _Sword.InstallSourceMap_swiginit(self, _Sword.new_InstallSourceMap(*args))

    def empty(self):
        return _Sword.InstallSourceMap_empty(self)

    def size(self):
        return _Sword.InstallSourceMap_size(self)

    def swap(self, v):
        return _Sword.InstallSourceMap_swap(self, v)

    def begin(self):
        return _Sword.InstallSourceMap_begin(self)

    def end(self):
        return _Sword.InstallSourceMap_end(self)

    def rbegin(self):
        return _Sword.InstallSourceMap_rbegin(self)

    def rend(self):
        return _Sword.InstallSourceMap_rend(self)

    def clear(self):
        return _Sword.InstallSourceMap_clear(self)

    def get_allocator(self):
        return _Sword.InstallSourceMap_get_allocator(self)

    def count(self, x):
        return _Sword.InstallSourceMap_count(self, x)

    def erase(self, *args):
        return _Sword.InstallSourceMap_erase(self, *args)

    def find(self, x):
        return _Sword.InstallSourceMap_find(self, x)

    def lower_bound(self, x):
        return _Sword.InstallSourceMap_lower_bound(self, x)

    def upper_bound(self, x):
        return _Sword.InstallSourceMap_upper_bound(self, x)
    __swig_destroy__ = _Sword.delete_InstallSourceMap

# Register InstallSourceMap in _Sword:
_Sword.InstallSourceMap_swigregister(InstallSourceMap)
class DirEntryVector(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

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

    def __nonzero__(self):
        return _Sword.DirEntryVector___nonzero__(self)

    def __bool__(self):
        return _Sword.DirEntryVector___bool__(self)

    def __len__(self):
        return _Sword.DirEntryVector___len__(self)

    def __getslice__(self, i, j):
        return _Sword.DirEntryVector___getslice__(self, i, j)

    def __setslice__(self, *args):
        return _Sword.DirEntryVector___setslice__(self, *args)

    def __delslice__(self, i, j):
        return _Sword.DirEntryVector___delslice__(self, i, j)

    def __delitem__(self, *args):
        return _Sword.DirEntryVector___delitem__(self, *args)

    def __getitem__(self, *args):
        return _Sword.DirEntryVector___getitem__(self, *args)

    def __setitem__(self, *args):
        return _Sword.DirEntryVector___setitem__(self, *args)

    def pop(self):
        return _Sword.DirEntryVector_pop(self)

    def append(self, x):
        return _Sword.DirEntryVector_append(self, x)

    def empty(self):
        return _Sword.DirEntryVector_empty(self)

    def size(self):
        return _Sword.DirEntryVector_size(self)

    def swap(self, v):
        return _Sword.DirEntryVector_swap(self, v)

    def begin(self):
        return _Sword.DirEntryVector_begin(self)

    def end(self):
        return _Sword.DirEntryVector_end(self)

    def rbegin(self):
        return _Sword.DirEntryVector_rbegin(self)

    def rend(self):
        return _Sword.DirEntryVector_rend(self)

    def clear(self):
        return _Sword.DirEntryVector_clear(self)

    def get_allocator(self):
        return _Sword.DirEntryVector_get_allocator(self)

    def pop_back(self):
        return _Sword.DirEntryVector_pop_back(self)

    def erase(self, *args):
        return _Sword.DirEntryVector_erase(self, *args)

    def __init__(self, *args):
        _Sword.DirEntryVector_swiginit(self, _Sword.new_DirEntryVector(*args))

    def push_back(self, x):
        return _Sword.DirEntryVector_push_back(self, x)

    def front(self):
        return _Sword.DirEntryVector_front(self)

    def back(self):
        return _Sword.DirEntryVector_back(self)

    def assign(self, n, x):
        return _Sword.DirEntryVector_assign(self, n, x)

    def resize(self, *args):
        return _Sword.DirEntryVector_resize(self, *args)

    def insert(self, *args):
        return _Sword.DirEntryVector_insert(self, *args)

    def reserve(self, n):
        return _Sword.DirEntryVector_reserve(self, n)

    def capacity(self):
        return _Sword.DirEntryVector_capacity(self)
    __swig_destroy__ = _Sword.delete_DirEntryVector

# Register DirEntryVector in _Sword:
_Sword.DirEntryVector_swigregister(DirEntryVector)
class SWClass(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr

    def isAssignableFrom(self, className):
        return _Sword.SWClass_isAssignableFrom(self, className)
    __swig_destroy__ = _Sword.delete_SWClass

# Register SWClass in _Sword:
_Sword.SWClass_swigregister(SWClass)
class SWObject(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, classdef):
        _Sword.SWObject_swiginit(self, _Sword.new_SWObject(classdef))

    def getClass(self):
        return _Sword.SWObject_getClass(self)
    __swig_destroy__ = _Sword.delete_SWObject

# Register SWObject in _Sword:
_Sword.SWObject_swigregister(SWObject)
class SWConfig(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        _Sword.SWConfig_swiginit(self, _Sword.new_SWConfig(*args))
    __swig_destroy__ = _Sword.delete_SWConfig

    def getSections(self):
        return _Sword.SWConfig_getSections(self)

    def load(self):
        return _Sword.SWConfig_load(self)

    def save(self):
        return _Sword.SWConfig_save(self)

    def augment(self, addFrom):
        return _Sword.SWConfig_augment(self, addFrom)

    def getSection(self, section):
        return _Sword.SWConfig_getSection(self, section)

    def getValue(self, section, key):
        return _Sword.SWConfig_getValue(self, section, key)

    def setValue(self, section, key, value):
        return _Sword.SWConfig_setValue(self, section, key, value)

    def getFileName(self):
        return _Sword.SWConfig_getFileName(self)

    def set(self, group, entry, value):
        return _Sword.SWConfig_set(self, group, entry, value)

    def get(self, group, entry):
        return _Sword.SWConfig_get(self, group, entry)

# Register SWConfig in _Sword:
_Sword.SWConfig_swigregister(SWConfig)
SWORD_VERSION_NUM = _Sword.SWORD_VERSION_NUM
SWORD_VERSION_STR = _Sword.SWORD_VERSION_STR
SWORD_VERSION_MAJOR = _Sword.SWORD_VERSION_MAJOR
SWORD_VERSION_MINOR = _Sword.SWORD_VERSION_MINOR
SWORD_VERSION_MICRO = _Sword.SWORD_VERSION_MICRO
SWORD_VERSION_NANO = _Sword.SWORD_VERSION_NANO
class SWVersion(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    major = property(_Sword.SWVersion_major_get, _Sword.SWVersion_major_set)
    minor = property(_Sword.SWVersion_minor_get, _Sword.SWVersion_minor_set)
    minor2 = property(_Sword.SWVersion_minor2_get, _Sword.SWVersion_minor2_set)
    minor3 = property(_Sword.SWVersion_minor3_get, _Sword.SWVersion_minor3_set)

    def __init__(self, *args):
        _Sword.SWVersion_swiginit(self, _Sword.new_SWVersion(*args))

    def compare(self, vi):
        return _Sword.SWVersion_compare(self, vi)

    def getText(self):
        return _Sword.SWVersion_getText(self)

    def __gt__(self, vi):
        return _Sword.SWVersion___gt__(self, vi)

    def __lt__(self, vi):
        return _Sword.SWVersion___lt__(self, vi)

    def __ge__(self, vi):
        return _Sword.SWVersion___ge__(self, vi)

    def __le__(self, vi):
        return _Sword.SWVersion___le__(self, vi)

    def __eq__(self, vi):
        return _Sword.SWVersion___eq__(self, vi)
    currentVersion = property(_Sword.SWVersion_currentVersion_get, _Sword.SWVersion_currentVersion_set)
    __swig_destroy__ = _Sword.delete_SWVersion

# Register SWVersion in _Sword:
_Sword.SWVersion_swigregister(SWVersion)
class RawVerse(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, ipath, fileMode=-1):
        _Sword.RawVerse_swiginit(self, _Sword.new_RawVerse(ipath, fileMode))
    __swig_destroy__ = _Sword.delete_RawVerse

    def findOffset(self, testmt, idxoff, start, end):
        return _Sword.RawVerse_findOffset(self, testmt, idxoff, start, end)

    def readText(self, testmt, start, size, buf):
        return _Sword.RawVerse_readText(self, testmt, start, size, buf)

    @staticmethod
    def createModule(*args):
        return _Sword.RawVerse_createModule(*args)

# Register RawVerse in _Sword:
_Sword.RawVerse_swigregister(RawVerse)
RawVerse.nl = _Sword.cvar.RawVerse_nl

class zVerse(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, ipath, fileMode=-1, blockType=3, icomp=None):
        _Sword.zVerse_swiginit(self, _Sword.new_zVerse(ipath, fileMode, blockType, icomp))
    __swig_destroy__ = _Sword.delete_zVerse

    def findOffset(self, testmt, idxoff, start, size, buffnum):
        return _Sword.zVerse_findOffset(self, testmt, idxoff, start, size, buffnum)

    def zReadText(self, testmt, start, size, buffnum, buf):
        return _Sword.zVerse_zReadText(self, testmt, start, size, buffnum, buf)

    def rawZFilter(self, buf, direction=0):
        return _Sword.zVerse_rawZFilter(self, buf, direction)

    @staticmethod
    def createModule(*args):
        return _Sword.zVerse_createModule(*args)

# Register zVerse in _Sword:
_Sword.zVerse_swigregister(zVerse)
VERSEBLOCKS = _Sword.VERSEBLOCKS
CHAPTERBLOCKS = _Sword.CHAPTERBLOCKS
BOOKBLOCKS = _Sword.BOOKBLOCKS
zVerse.uniqueIndexID = _Sword.cvar.zVerse_uniqueIndexID

class RawStr(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, ipath, fileMode=-1, caseSensitive=False):
        _Sword.RawStr_swiginit(self, _Sword.new_RawStr(ipath, fileMode, caseSensitive))
    __swig_destroy__ = _Sword.delete_RawStr

    def getIDXBuf(self, ioffset, buf):
        return _Sword.RawStr_getIDXBuf(self, ioffset, buf)

    def getIDXBufDat(self, ioffset, buf):
        return _Sword.RawStr_getIDXBufDat(self, ioffset, buf)

    def findOffset(self, key, start, size, away=0, idxoff=None):
        return _Sword.RawStr_findOffset(self, key, start, size, away, idxoff)

    def readText(self, start, size, idxbuf, buf):
        return _Sword.RawStr_readText(self, start, size, idxbuf, buf)

    @staticmethod
    def createModule(path):
        return _Sword.RawStr_createModule(path)

# Register RawStr in _Sword:
_Sword.RawStr_swigregister(RawStr)
RawStr.nl = _Sword.cvar.RawStr_nl

class RawStr4(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, ipath, fileMode=-1, caseSensitive=False):
        _Sword.RawStr4_swiginit(self, _Sword.new_RawStr4(ipath, fileMode, caseSensitive))
    __swig_destroy__ = _Sword.delete_RawStr4

    def getIDXBuf(self, ioffset, buf):
        return _Sword.RawStr4_getIDXBuf(self, ioffset, buf)

    def getIDXBufDat(self, ioffset, buf):
        return _Sword.RawStr4_getIDXBufDat(self, ioffset, buf)

    def findOffset(self, key, start, size, away=0, idxoff=None):
        return _Sword.RawStr4_findOffset(self, key, start, size, away, idxoff)

    def readText(self, start, size, idxbuf, buf):
        return _Sword.RawStr4_readText(self, start, size, idxbuf, buf)

    @staticmethod
    def createModule(path):
        return _Sword.RawStr4_createModule(path)

# Register RawStr4 in _Sword:
_Sword.RawStr4_swigregister(RawStr4)
RawStr4.nl = _Sword.cvar.RawStr4_nl

class zStr(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, ipath, fileMode=-1, blockCount=100, icomp=None, caseSensitive=False):
        _Sword.zStr_swiginit(self, _Sword.new_zStr(ipath, fileMode, blockCount, icomp, caseSensitive))
    __swig_destroy__ = _Sword.delete_zStr

    def findKeyIndex(self, ikey, idxoff, away=0):
        return _Sword.zStr_findKeyIndex(self, ikey, idxoff, away)

    def getText(self, index, idxbuf, buf):
        return _Sword.zStr_getText(self, index, idxbuf, buf)

    def setText(self, ikey, buf, len=-1):
        return _Sword.zStr_setText(self, ikey, buf, len)

    def linkEntry(self, destkey, srckey):
        return _Sword.zStr_linkEntry(self, destkey, srckey)

    def rawZFilter(self, buf, direction=0):
        return _Sword.zStr_rawZFilter(self, buf, direction)

    @staticmethod
    def createModule(path):
        return _Sword.zStr_createModule(path)

# Register zStr in _Sword:
_Sword.zStr_swigregister(zStr)
KEYERR_OUTOFBOUNDS = _Sword.KEYERR_OUTOFBOUNDS
class SW_POSITION(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, ipos):
        _Sword.SW_POSITION_swiginit(self, _Sword.new_SW_POSITION(ipos))

    def getPosition(self):
        return _Sword.SW_POSITION_getPosition(self)
    __swig_destroy__ = _Sword.delete_SW_POSITION

# Register SW_POSITION in _Sword:
_Sword.SW_POSITION_swigregister(SW_POSITION)
class SWKey(SWObject):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        _Sword.SWKey_swiginit(self, _Sword.new_SWKey(*args))
    __swig_destroy__ = _Sword.delete_SWKey

    def clone(self):
        return _Sword.SWKey_clone(self)

    def isPersist(self):
        return _Sword.SWKey_isPersist(self)

    def setPersist(self, ipersist):
        return _Sword.SWKey_setPersist(self, ipersist)

    def popError(self):
        return _Sword.SWKey_popError(self)

    def getError(self):
        return _Sword.SWKey_getError(self)

    def setError(self, err):
        return _Sword.SWKey_setError(self, err)

    def setText(self, ikey):
        return _Sword.SWKey_setText(self, ikey)

    def copyFrom(self, ikey):
        return _Sword.SWKey_copyFrom(self, ikey)

    def positionFrom(self, ikey):
        return _Sword.SWKey_positionFrom(self, ikey)

    def getText(self):
        return _Sword.SWKey_getText(self)

    def getShortText(self):
        return _Sword.SWKey_getShortText(self)

    def getRangeText(self):
        return _Sword.SWKey_getRangeText(self)

    def getShortRangeText(self):
        return _Sword.SWKey_getShortRangeText(self)

    def getOSISRefRangeText(self):
        return _Sword.SWKey_getOSISRefRangeText(self)

    def isBoundSet(self):
        return _Sword.SWKey_isBoundSet(self)

    def clearBounds(self):
        return _Sword.SWKey_clearBounds(self)

    def compare(self, ikey):
        return _Sword.SWKey_compare(self, ikey)

    def equals(self, ikey):
        return _Sword.SWKey_equals(self, ikey)

    def setPosition(self, arg2):
        return _Sword.SWKey_setPosition(self, arg2)

    def decrement(self, steps=1):
        return _Sword.SWKey_decrement(self, steps)

    def increment(self, steps=1):
        return _Sword.SWKey_increment(self, steps)

    def isTraversable(self):
        return _Sword.SWKey_isTraversable(self)

    def getLocale(self):
        return _Sword.SWKey_getLocale(self)

    def setLocale(self, name):
        return _Sword.SWKey_setLocale(self, name)

    def getIndex(self):
        return _Sword.SWKey_getIndex(self)

    def setIndex(self, iindex):
        return _Sword.SWKey_setIndex(self, iindex)

    def __eq__(self, ikey):
        return _Sword.SWKey___eq__(self, ikey)

    def __ne__(self, ikey):
        return _Sword.SWKey___ne__(self, ikey)

    def __gt__(self, ikey):
        return _Sword.SWKey___gt__(self, ikey)

    def __lt__(self, ikey):
        return _Sword.SWKey___lt__(self, ikey)

    def __ge__(self, ikey):
        return _Sword.SWKey___ge__(self, ikey)

    def __le__(self, ikey):
        return _Sword.SWKey___le__(self, ikey)

    def __isub__(self, steps):
        return _Sword.SWKey___isub__(self, steps)

    def __iadd__(self, steps):
        return _Sword.SWKey___iadd__(self, steps)

# Register SWKey in _Sword:
_Sword.SWKey_swigregister(SWKey)
class ListKey(SWKey):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        _Sword.ListKey_swiginit(self, _Sword.new_ListKey(*args))
    __swig_destroy__ = _Sword.delete_ListKey

    def clone(self):
        return _Sword.ListKey_clone(self)

    def clear(self):
        return _Sword.ListKey_clear(self)

    def getCount(self):
        return _Sword.ListKey_getCount(self)

    def remove(self):
        return _Sword.ListKey_remove(self)

    def setToElement(self, *args):
        return _Sword.ListKey_setToElement(self, *args)

    def getElement(self, *args):
        return _Sword.ListKey_getElement(self, *args)

    def add(self, ikey):
        return _Sword.ListKey_add(self, ikey)

    def copyFrom(self, *args):
        return _Sword.ListKey_copyFrom(self, *args)

    def setPosition(self, pos):
        return _Sword.ListKey_setPosition(self, pos)

    def decrement(self, step=1):
        return _Sword.ListKey_decrement(self, step)

    def increment(self, step=1):
        return _Sword.ListKey_increment(self, step)

    def nextElement(self):
        return _Sword.ListKey_nextElement(self)

    def isTraversable(self):
        return _Sword.ListKey_isTraversable(self)

    def getIndex(self):
        return _Sword.ListKey_getIndex(self)

    def getRangeText(self):
        return _Sword.ListKey_getRangeText(self)

    def getOSISRefRangeText(self):
        return _Sword.ListKey_getOSISRefRangeText(self)

    def getShortRangeText(self):
        return _Sword.ListKey_getShortRangeText(self)

    def getShortText(self):
        return _Sword.ListKey_getShortText(self)

    def setIndex(self, index):
        return _Sword.ListKey_setIndex(self, index)

    def getText(self):
        return _Sword.ListKey_getText(self)

    def setText(self, ikey):
        return _Sword.ListKey_setText(self, ikey)

    def sort(self):
        return _Sword.ListKey_sort(self)

    def __eq__(self, ikey):
        return _Sword.ListKey___eq__(self, ikey)

    def __ne__(self, ikey):
        return _Sword.ListKey___ne__(self, ikey)

    def __gt__(self, ikey):
        return _Sword.ListKey___gt__(self, ikey)

    def __lt__(self, ikey):
        return _Sword.ListKey___lt__(self, ikey)

    def __ge__(self, ikey):
        return _Sword.ListKey___ge__(self, ikey)

    def __le__(self, ikey):
        return _Sword.ListKey___le__(self, ikey)

    def __isub__(self, steps):
        return _Sword.ListKey___isub__(self, steps)

    def __iadd__(self, steps):
        return _Sword.ListKey___iadd__(self, steps)

    @staticmethod
    def castTo(o):
        return _Sword.ListKey_castTo(o)

# Register ListKey in _Sword:
_Sword.ListKey_swigregister(ListKey)
class VerseKey(SWKey):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        _Sword.VerseKey_swiginit(self, _Sword.new_VerseKey(*args))
    __swig_destroy__ = _Sword.delete_VerseKey

    def setLowerBound(self, lb):
        return _Sword.VerseKey_setLowerBound(self, lb)

    def setUpperBound(self, ub):
        return _Sword.VerseKey_setUpperBound(self, ub)

    def getLowerBound(self):
        return _Sword.VerseKey_getLowerBound(self)

    def getUpperBound(self):
        return _Sword.VerseKey_getUpperBound(self)

    def clearBounds(self):
        return _Sword.VerseKey_clearBounds(self)

    def clone(self):
        return _Sword.VerseKey_clone(self)

    def getText(self):
        return _Sword.VerseKey_getText(self)

    def getShortText(self):
        return _Sword.VerseKey_getShortText(self)

    def setText(self, *args):
        return _Sword.VerseKey_setText(self, *args)

    def copyFrom(self, *args):
        return _Sword.VerseKey_copyFrom(self, *args)

    def positionFrom(self, ikey):
        return _Sword.VerseKey_positionFrom(self, ikey)

    def setPosition(self, newpos):
        return _Sword.VerseKey_setPosition(self, newpos)

    def decrement(self, steps=1):
        return _Sword.VerseKey_decrement(self, steps)

    def increment(self, steps=1):
        return _Sword.VerseKey_increment(self, steps)

    def isTraversable(self):
        return _Sword.VerseKey_isTraversable(self)

    def getBookName(self):
        return _Sword.VerseKey_getBookName(self)

    def setBookName(self, bname):
        return _Sword.VerseKey_setBookName(self, bname)

    def getBookAbbrev(self):
        return _Sword.VerseKey_getBookAbbrev(self)

    def getTestament(self):
        return _Sword.VerseKey_getTestament(self)

    def getTestamentMax(self):
        return _Sword.VerseKey_getTestamentMax(self)

    def getBook(self):
        return _Sword.VerseKey_getBook(self)

    def getBookMax(self):
        return _Sword.VerseKey_getBookMax(self)

    def getChapter(self):
        return _Sword.VerseKey_getChapter(self)

    def getChapterMax(self):
        return _Sword.VerseKey_getChapterMax(self)

    def getVerse(self):
        return _Sword.VerseKey_getVerse(self)

    def getVerseMax(self):
        return _Sword.VerseKey_getVerseMax(self)

    def getSuffix(self):
        return _Sword.VerseKey_getSuffix(self)

    def setTestament(self, itestament):
        return _Sword.VerseKey_setTestament(self, itestament)

    def setBook(self, ibook):
        return _Sword.VerseKey_setBook(self, ibook)

    def setChapter(self, ichapter):
        return _Sword.VerseKey_setChapter(self, ichapter)

    def setVerse(self, iverse):
        return _Sword.VerseKey_setVerse(self, iverse)

    def setSuffix(self, isuffix):
        return _Sword.VerseKey_setSuffix(self, isuffix)

    def normalize(self, autocheck=False):
        return _Sword.VerseKey_normalize(self, autocheck)

    def setAutoNormalize(self, iautonorm):
        return _Sword.VerseKey_setAutoNormalize(self, iautonorm)

    def isAutoNormalize(self):
        return _Sword.VerseKey_isAutoNormalize(self)

    def setIntros(self, val):
        return _Sword.VerseKey_setIntros(self, val)

    def isIntros(self):
        return _Sword.VerseKey_isIntros(self)

    def getIndex(self):
        return _Sword.VerseKey_getIndex(self)

    def setIndex(self, iindex):
        return _Sword.VerseKey_setIndex(self, iindex)

    def getTestamentIndex(self):
        return _Sword.VerseKey_getTestamentIndex(self)

    def getOSISRef(self):
        return _Sword.VerseKey_getOSISRef(self)

    @staticmethod
    def convertToOSIS(inRef, defaultKey):
        return _Sword.VerseKey_convertToOSIS(inRef, defaultKey)

    def parseVerseList(self, buf, defaultKey=None, expandRange=False, useChapterAsVerse=False):
        return _Sword.VerseKey_parseVerseList(self, buf, defaultKey, expandRange, useChapterAsVerse)

    def getRangeText(self):
        return _Sword.VerseKey_getRangeText(self)

    def getShortRangeText(self):
        return _Sword.VerseKey_getShortRangeText(self)

    def getOSISRefRangeText(self):
        return _Sword.VerseKey_getOSISRefRangeText(self)

    def compare(self, ikey):
        return _Sword.VerseKey_compare(self, ikey)

    def _compare(self, ikey):
        return _Sword.VerseKey__compare(self, ikey)

    def setVersificationSystem(self, name):
        return _Sword.VerseKey_setVersificationSystem(self, name)

    def getVersificationSystem(self):
        return _Sword.VerseKey_getVersificationSystem(self)

    def validateCurrentLocale(self):
        return _Sword.VerseKey_validateCurrentLocale(self)

    def __eq__(self, ikey):
        return _Sword.VerseKey___eq__(self, ikey)

    def __ne__(self, ikey):
        return _Sword.VerseKey___ne__(self, ikey)

    def __gt__(self, ikey):
        return _Sword.VerseKey___gt__(self, ikey)

    def __lt__(self, ikey):
        return _Sword.VerseKey___lt__(self, ikey)

    def __ge__(self, ikey):
        return _Sword.VerseKey___ge__(self, ikey)

    def __le__(self, ikey):
        return _Sword.VerseKey___le__(self, ikey)

    def __isub__(self, steps):
        return _Sword.VerseKey___isub__(self, steps)

    def __iadd__(self, steps):
        return _Sword.VerseKey___iadd__(self, steps)

    @staticmethod
    def castTo(o):
        return _Sword.VerseKey_castTo(o)

    def bookCount(self, testament):
        return _Sword.VerseKey_bookCount(self, testament)

    def getBookCount(self):
        return _Sword.VerseKey_getBookCount(self)

    def bookName(self, testament, book):
        return _Sword.VerseKey_bookName(self, testament, book)

    def getBookNumberByOSISName(self, bookname):
        return _Sword.VerseKey_getBookNumberByOSISName(self, bookname)

    def getOSISBookName(self, *args):
        return _Sword.VerseKey_getOSISBookName(self, *args)

    def chapterCount(self, testament, book):
        return _Sword.VerseKey_chapterCount(self, testament, book)

    def verseCount(self, testament, book, chapter):
        return _Sword.VerseKey_verseCount(self, testament, book, chapter)

# Register VerseKey in _Sword:
_Sword.VerseKey_swigregister(VerseKey)
class abbrev(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    ab = property(_Sword.abbrev_ab_get)
    osis = property(_Sword.abbrev_osis_get, _Sword.abbrev_osis_set)

    def getAbbrevCount(self):
        return _Sword.abbrev_getAbbrevCount(self)

    def getAbbrevData(self, i):
        return _Sword.abbrev_getAbbrevData(self, i)

    def __init__(self):
        _Sword.abbrev_swiginit(self, _Sword.new_abbrev())
    __swig_destroy__ = _Sword.delete_abbrev

# Register abbrev in _Sword:
_Sword.abbrev_swigregister(abbrev)
class sbook(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    name = property(_Sword.sbook_name_get)
    osis = property(_Sword.sbook_osis_get, _Sword.sbook_osis_set)
    prefAbbrev = property(_Sword.sbook_prefAbbrev_get)
    chapmax = property(_Sword.sbook_chapmax_get, _Sword.sbook_chapmax_set)

    def verseMax(self, chapter):
        return _Sword.sbook_verseMax(self, chapter)

    def __init__(self):
        _Sword.sbook_swiginit(self, _Sword.new_sbook())
    __swig_destroy__ = _Sword.delete_sbook

# Register sbook in _Sword:
_Sword.sbook_swigregister(sbook)
class VersificationMgr(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self):
        _Sword.VersificationMgr_swiginit(self, _Sword.new_VersificationMgr())
    __swig_destroy__ = _Sword.delete_VersificationMgr

    @staticmethod
    def getSystemVersificationMgr():
        return _Sword.VersificationMgr_getSystemVersificationMgr()

    @staticmethod
    def setSystemVersificationMgr(newVersificationMgr):
        return _Sword.VersificationMgr_setSystemVersificationMgr(newVersificationMgr)

    def getVersificationSystems(self):
        return _Sword.VersificationMgr_getVersificationSystems(self)

    def getVersificationSystem(self, name):
        return _Sword.VersificationMgr_getVersificationSystem(self, name)

    def registerVersificationSystem(self, *args):
        return _Sword.VersificationMgr_registerVersificationSystem(self, *args)

# Register VersificationMgr in _Sword:
_Sword.VersificationMgr_swigregister(VersificationMgr)
class TreeKey(SWKey):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr
    posChangeListener = property(_Sword.TreeKey_posChangeListener_get, _Sword.TreeKey_posChangeListener_set)

    def setPositionChangeListener(self, pcl):
        return _Sword.TreeKey_setPositionChangeListener(self, pcl)
    __swig_destroy__ = _Sword.delete_TreeKey

    def getLocalName(self):
        return _Sword.TreeKey_getLocalName(self)

    def setLocalName(self, arg2):
        return _Sword.TreeKey_setLocalName(self, arg2)

    def getLevel(self):
        return _Sword.TreeKey_getLevel(self)

    def getUserData(self, size=None):
        return _Sword.TreeKey_getUserData(self, size)

    def setUserData(self, userData, size=0):
        return _Sword.TreeKey_setUserData(self, userData, size)

    def root(self):
        return _Sword.TreeKey_root(self)

    def parent(self):
        return _Sword.TreeKey_parent(self)

    def firstChild(self):
        return _Sword.TreeKey_firstChild(self)

    def nextSibling(self):
        return _Sword.TreeKey_nextSibling(self)

    def previousSibling(self):
        return _Sword.TreeKey_previousSibling(self)

    def hasChildren(self):
        return _Sword.TreeKey_hasChildren(self)

    def append(self):
        return _Sword.TreeKey_append(self)

    def appendChild(self):
        return _Sword.TreeKey_appendChild(self)

    def insertBefore(self):
        return _Sword.TreeKey_insertBefore(self)

    def remove(self):
        return _Sword.TreeKey_remove(self)

    def setOffset(self, offset):
        return _Sword.TreeKey_setOffset(self, offset)

    def getOffset(self):
        return _Sword.TreeKey_getOffset(self)

    def setText(self, ikey):
        return _Sword.TreeKey_setText(self, ikey)

    def setPosition(self, p):
        return _Sword.TreeKey_setPosition(self, p)

    def getText(self):
        return _Sword.TreeKey_getText(self)

    def compare(self, ikey):
        return _Sword.TreeKey_compare(self, ikey)

    def decrement(self, steps=1):
        return _Sword.TreeKey_decrement(self, steps)

    def increment(self, steps=1):
        return _Sword.TreeKey_increment(self, steps)

    def isTraversable(self):
        return _Sword.TreeKey_isTraversable(self)

    def getIndex(self):
        return _Sword.TreeKey_getIndex(self)

    def setIndex(self, iindex):
        return _Sword.TreeKey_setIndex(self, iindex)

    def assureKeyPath(self, keyPath=None):
        return _Sword.TreeKey_assureKeyPath(self, keyPath)

    def save(self):
        return _Sword.TreeKey_save(self)

    def __eq__(self, ikey):
        return _Sword.TreeKey___eq__(self, ikey)

    def __ne__(self, ikey):
        return _Sword.TreeKey___ne__(self, ikey)

    def __gt__(self, ikey):
        return _Sword.TreeKey___gt__(self, ikey)

    def __lt__(self, ikey):
        return _Sword.TreeKey___lt__(self, ikey)

    def __ge__(self, ikey):
        return _Sword.TreeKey___ge__(self, ikey)

    def __le__(self, ikey):
        return _Sword.TreeKey___le__(self, ikey)

    def __isub__(self, steps):
        return _Sword.TreeKey___isub__(self, steps)

    def __iadd__(self, steps):
        return _Sword.TreeKey___iadd__(self, steps)

    @staticmethod
    def castTo(o):
        return _Sword.TreeKey_castTo(o)

# Register TreeKey in _Sword:
_Sword.TreeKey_swigregister(TreeKey)
builtin_abbrevs = cvar.builtin_abbrevs

class TreeKeyIdx(TreeKey):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        _Sword.TreeKeyIdx_swiginit(self, _Sword.new_TreeKeyIdx(*args))
    __swig_destroy__ = _Sword.delete_TreeKeyIdx

    def clone(self):
        return _Sword.TreeKeyIdx_clone(self)

    def getLocalName(self):
        return _Sword.TreeKeyIdx_getLocalName(self)

    def setLocalName(self, arg2):
        return _Sword.TreeKeyIdx_setLocalName(self, arg2)

    def getUserData(self, size=None):
        return _Sword.TreeKeyIdx_getUserData(self, size)

    def setUserData(self, userData, size=0):
        return _Sword.TreeKeyIdx_setUserData(self, userData, size)

    def root(self):
        return _Sword.TreeKeyIdx_root(self)

    def parent(self):
        return _Sword.TreeKeyIdx_parent(self)

    def firstChild(self):
        return _Sword.TreeKeyIdx_firstChild(self)

    def nextSibling(self):
        return _Sword.TreeKeyIdx_nextSibling(self)

    def previousSibling(self):
        return _Sword.TreeKeyIdx_previousSibling(self)

    def hasChildren(self):
        return _Sword.TreeKeyIdx_hasChildren(self)

    def append(self):
        return _Sword.TreeKeyIdx_append(self)

    def appendChild(self):
        return _Sword.TreeKeyIdx_appendChild(self)

    def insertBefore(self):
        return _Sword.TreeKeyIdx_insertBefore(self)

    def remove(self):
        return _Sword.TreeKeyIdx_remove(self)

    def save(self):
        return _Sword.TreeKeyIdx_save(self)

    def copyFrom(self, *args):
        return _Sword.TreeKeyIdx_copyFrom(self, *args)

    def setOffset(self, offset):
        return _Sword.TreeKeyIdx_setOffset(self, offset)

    def getOffset(self):
        return _Sword.TreeKeyIdx_getOffset(self)

    def getLevel(self):
        return _Sword.TreeKeyIdx_getLevel(self)

    def __eq__(self, ikey):
        return _Sword.TreeKeyIdx___eq__(self, ikey)

    def __ne__(self, ikey):
        return _Sword.TreeKeyIdx___ne__(self, ikey)

    def __gt__(self, ikey):
        return _Sword.TreeKeyIdx___gt__(self, ikey)

    def __lt__(self, ikey):
        return _Sword.TreeKeyIdx___lt__(self, ikey)

    def __ge__(self, ikey):
        return _Sword.TreeKeyIdx___ge__(self, ikey)

    def __le__(self, ikey):
        return _Sword.TreeKeyIdx___le__(self, ikey)

    def __isub__(self, steps):
        return _Sword.TreeKeyIdx___isub__(self, steps)

    def __iadd__(self, steps):
        return _Sword.TreeKeyIdx___iadd__(self, steps)

    def setText(self, ikey):
        return _Sword.TreeKeyIdx_setText(self, ikey)

    def setPosition(self, p):
        return _Sword.TreeKeyIdx_setPosition(self, p)

    def getText(self):
        return _Sword.TreeKeyIdx_getText(self)

    def _compare(self, ikey):
        return _Sword.TreeKeyIdx__compare(self, ikey)

    def compare(self, ikey):
        return _Sword.TreeKeyIdx_compare(self, ikey)

    def decrement(self, steps=1):
        return _Sword.TreeKeyIdx_decrement(self, steps)

    def increment(self, steps=1):
        return _Sword.TreeKeyIdx_increment(self, steps)

    def isTraversable(self):
        return _Sword.TreeKeyIdx_isTraversable(self)

    @staticmethod
    def create(path):
        return _Sword.TreeKeyIdx_create(path)

    @staticmethod
    def castTo(o):
        return _Sword.TreeKeyIdx_castTo(o)

# Register TreeKeyIdx in _Sword:
_Sword.TreeKeyIdx_swigregister(TreeKeyIdx)
class VerseTreeKey(VerseKey):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        _Sword.VerseTreeKey_swiginit(self, _Sword.new_VerseTreeKey(*args))
    __swig_destroy__ = _Sword.delete_VerseTreeKey

    def clone(self):
        return _Sword.VerseTreeKey_clone(self)

    def isTraversable(self):
        return _Sword.VerseTreeKey_isTraversable(self)

    def getTreeKey(self, *args):
        return _Sword.VerseTreeKey_getTreeKey(self, *args)

    def positionChanged(self):
        return _Sword.VerseTreeKey_positionChanged(self)
    internalPosChange = property(_Sword.VerseTreeKey_internalPosChange_get, _Sword.VerseTreeKey_internalPosChange_set)

    def decrement(self, steps=1):
        return _Sword.VerseTreeKey_decrement(self, steps)

    def increment(self, steps=1):
        return _Sword.VerseTreeKey_increment(self, steps)

    def setPosition(self, newpos):
        return _Sword.VerseTreeKey_setPosition(self, newpos)

    def newIndex(self):
        return _Sword.VerseTreeKey_newIndex(self)

    def __eq__(self, ikey):
        return _Sword.VerseTreeKey___eq__(self, ikey)

    def __ne__(self, ikey):
        return _Sword.VerseTreeKey___ne__(self, ikey)

    def __gt__(self, ikey):
        return _Sword.VerseTreeKey___gt__(self, ikey)

    def __lt__(self, ikey):
        return _Sword.VerseTreeKey___lt__(self, ikey)

    def __ge__(self, ikey):
        return _Sword.VerseTreeKey___ge__(self, ikey)

    def __le__(self, ikey):
        return _Sword.VerseTreeKey___le__(self, ikey)

    def __isub__(self, steps):
        return _Sword.VerseTreeKey___isub__(self, steps)

    def __iadd__(self, steps):
        return _Sword.VerseTreeKey___iadd__(self, steps)

    @staticmethod
    def castTo(o):
        return _Sword.VerseTreeKey_castTo(o)

# Register VerseTreeKey in _Sword:
_Sword.VerseTreeKey_swigregister(VerseTreeKey)
class SWDisplay(SWObject):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr
    __swig_destroy__ = _Sword.delete_SWDisplay

    def display(self, imodule):
        return _Sword.SWDisplay_display(self, imodule)

# Register SWDisplay in _Sword:
_Sword.SWDisplay_swigregister(SWDisplay)
class SWFilter(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr
    __swig_destroy__ = _Sword.delete_SWFilter

    def processText(self, text, key=None, module=None):
        return _Sword.SWFilter_processText(self, text, key, module)

    def getHeader(self):
        return _Sword.SWFilter_getHeader(self)

# Register SWFilter in _Sword:
_Sword.SWFilter_swigregister(SWFilter)
class SWOptionFilter(SWFilter):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr
    __swig_destroy__ = _Sword.delete_SWOptionFilter

    def isBoolean(self):
        return _Sword.SWOptionFilter_isBoolean(self)

    def getOptionName(self):
        return _Sword.SWOptionFilter_getOptionName(self)

    def getOptionTip(self):
        return _Sword.SWOptionFilter_getOptionTip(self)

    def getOptionValue(self):
        return _Sword.SWOptionFilter_getOptionValue(self)

    def setOptionValue(self, ival):
        return _Sword.SWOptionFilter_setOptionValue(self, ival)

    @staticmethod
    def castTo(o):
        return _Sword.SWOptionFilter_castTo(o)

# Register SWOptionFilter in _Sword:
_Sword.SWOptionFilter_swigregister(SWOptionFilter)
class SWFilterMgr(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self):
        _Sword.SWFilterMgr_swiginit(self, _Sword.new_SWFilterMgr())
    __swig_destroy__ = _Sword.delete_SWFilterMgr

    def setParentMgr(self, parentMgr):
        return _Sword.SWFilterMgr_setParentMgr(self, parentMgr)

    def getParentMgr(self):
        return _Sword.SWFilterMgr_getParentMgr(self)

    def addGlobalOptions(self, module, section, start, end):
        return _Sword.SWFilterMgr_addGlobalOptions(self, module, section, start, end)

    def addLocalOptions(self, module, section, start, end):
        return _Sword.SWFilterMgr_addLocalOptions(self, module, section, start, end)

    def addEncodingFilters(self, module, section):
        return _Sword.SWFilterMgr_addEncodingFilters(self, module, section)

    def addRenderFilters(self, module, section):
        return _Sword.SWFilterMgr_addRenderFilters(self, module, section)

    def addStripFilters(self, module, section):
        return _Sword.SWFilterMgr_addStripFilters(self, module, section)

    def addRawFilters(self, module, section):
        return _Sword.SWFilterMgr_addRawFilters(self, module, section)

# Register SWFilterMgr in _Sword:
_Sword.SWFilterMgr_swigregister(SWFilterMgr)
class StringMgr(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr

    @staticmethod
    def setSystemStringMgr(newStringMgr):
        return _Sword.StringMgr_setSystemStringMgr(newStringMgr)

    @staticmethod
    def getSystemStringMgr():
        return _Sword.StringMgr_getSystemStringMgr()

    @staticmethod
    def hasUTF8Support():
        return _Sword.StringMgr_hasUTF8Support()

    def upperUTF8(self, text, max=0):
        return _Sword.StringMgr_upperUTF8(self, text, max)

    def lowerUTF8(self, text, max=0):
        return _Sword.StringMgr_lowerUTF8(self, text, max)

    def isUpper(self, character):
        return _Sword.StringMgr_isUpper(self, character)

    def isLower(self, character):
        return _Sword.StringMgr_isLower(self, character)

    def isDigit(self, character):
        return _Sword.StringMgr_isDigit(self, character)

    def isAlpha(self, character):
        return _Sword.StringMgr_isAlpha(self, character)

    def upperLatin1(self, text, max=0):
        return _Sword.StringMgr_upperLatin1(self, text, max)

# Register StringMgr in _Sword:
_Sword.StringMgr_swigregister(StringMgr)

def toupperstr(t, max=0):
    return _Sword.toupperstr(t, max)

def tolowerstr(t, max=0):
    return _Sword.tolowerstr(t, max)

def toupperstr_utf8(t, max=0):
    return _Sword.toupperstr_utf8(t, max)
class PyStringMgr(StringMgr):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def upperUTF8(self, text, max=0):
        return _Sword.PyStringMgr_upperUTF8(self, text, max)

    def getUpper(self, test):
        return _Sword.PyStringMgr_getUpper(self, test)

    def __init__(self):
        if self.__class__ == PyStringMgr:
            _self = None
        else:
            _self = self
        _Sword.PyStringMgr_swiginit(self, _Sword.new_PyStringMgr(_self, ))
    __swig_destroy__ = _Sword.delete_PyStringMgr
    def __disown__(self):
        self.this.disown()
        _Sword.disown_PyStringMgr(self)
        return weakref.proxy(self)

    def supportsUnicode(self):
        return _Sword.PyStringMgr_supportsUnicode(self)

# Register PyStringMgr in _Sword:
_Sword.PyStringMgr_swigregister(PyStringMgr)
class SWSearchable(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr
    __swig_destroy__ = _Sword.delete_SWSearchable

    def deleteSearchFramework(self):
        return _Sword.SWSearchable_deleteSearchFramework(self)

    def hasSearchFramework(self):
        return _Sword.SWSearchable_hasSearchFramework(self)

    def isSearchOptimallySupported(self, istr, searchType, flags, scope):
        return _Sword.SWSearchable_isSearchOptimallySupported(self, istr, searchType, flags, scope)

    def isSearchSupported(self, istr, searchType=0, flags=0, scope=None):
        return _Sword.SWSearchable_isSearchSupported(self, istr, searchType, flags, scope)

    def doSearch(self, istr, searchType=0, flags=0, scope=None):
        return _Sword.SWSearchable_doSearch(self, istr, searchType, flags, scope)

# Register SWSearchable in _Sword:
_Sword.SWSearchable_swigregister(SWSearchable)
DIRECTION_LTR = _Sword.DIRECTION_LTR
DIRECTION_RTL = _Sword.DIRECTION_RTL
DIRECTION_BIDI = _Sword.DIRECTION_BIDI
FMT_UNKNOWN = _Sword.FMT_UNKNOWN
FMT_PLAIN = _Sword.FMT_PLAIN
FMT_THML = _Sword.FMT_THML
FMT_GBF = _Sword.FMT_GBF
FMT_HTML = _Sword.FMT_HTML
FMT_HTMLHREF = _Sword.FMT_HTMLHREF
FMT_RTF = _Sword.FMT_RTF
FMT_OSIS = _Sword.FMT_OSIS
FMT_WEBIF = _Sword.FMT_WEBIF
FMT_TEI = _Sword.FMT_TEI
FMT_XHTML = _Sword.FMT_XHTML
FMT_LATEX = _Sword.FMT_LATEX
ENC_UNKNOWN = _Sword.ENC_UNKNOWN
ENC_LATIN1 = _Sword.ENC_LATIN1
ENC_UTF8 = _Sword.ENC_UTF8
ENC_SCSU = _Sword.ENC_SCSU
ENC_UTF16 = _Sword.ENC_UTF16
ENC_RTF = _Sword.ENC_RTF
ENC_HTML = _Sword.ENC_HTML
BIB_BIBTEX = _Sword.BIB_BIBTEX
SEARCHFLAG_MATCHWHOLEENTRY = _Sword.SEARCHFLAG_MATCHWHOLEENTRY
SEARCHFLAG_STRICTBOUNDARIES = _Sword.SEARCHFLAG_STRICTBOUNDARIES
class SWModule(SWSearchable):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr
    terminateSearch = property(_Sword.SWModule_terminateSearch_get, _Sword.SWModule_terminateSearch_set)
    __swig_destroy__ = _Sword.delete_SWModule

    def popError(self):
        return _Sword.SWModule_popError(self)

    def isUnicode(self):
        return _Sword.SWModule_isUnicode(self)

    def getConfigEntry(self, key):
        return _Sword.SWModule_getConfigEntry(self, key)

    def getBibliography(self, *args):
        return _Sword.SWModule_getBibliography(self, *args)

    def getEntrySize(self):
        return _Sword.SWModule_getEntrySize(self)

    def setKey(self, ikey):
        return _Sword.SWModule_setKey(self, ikey)

    def setKeyText(self, keyText):
        return _Sword.SWModule_setKeyText(self, keyText)

    def getKey(self):
        return _Sword.SWModule_getKey(self)

    def getKeyText(self):
        return _Sword.SWModule_getKeyText(self)

    def getIndex(self):
        return _Sword.SWModule_getIndex(self)

    def setIndex(self, iindex):
        return _Sword.SWModule_setIndex(self, iindex)

    def display(self):
        return _Sword.SWModule_display(self)

    def getDisplay(self):
        return _Sword.SWModule_getDisplay(self)

    def setDisplay(self, idisp):
        return _Sword.SWModule_setDisplay(self, idisp)

    def getName(self):
        return _Sword.SWModule_getName(self)

    def getDescription(self):
        return _Sword.SWModule_getDescription(self)

    def getType(self):
        return _Sword.SWModule_getType(self)

    def setType(self, imodtype):
        return _Sword.SWModule_setType(self, imodtype)

    def getDirection(self):
        return _Sword.SWModule_getDirection(self)

    def getEncoding(self):
        return _Sword.SWModule_getEncoding(self)

    def getMarkup(self):
        return _Sword.SWModule_getMarkup(self)

    def getLanguage(self):
        return _Sword.SWModule_getLanguage(self)

    def createKey(self):
        return _Sword.SWModule_createKey(self)

    def getRawEntryBuf(self):
        return _Sword.SWModule_getRawEntryBuf(self)

    def getRawEntry(self):
        return _Sword.SWModule_getRawEntry(self)

    def isWritable(self):
        return _Sword.SWModule_isWritable(self)

    @staticmethod
    def createModule(path):
        return _Sword.SWModule_createModule(path)

    def setEntry(self, inbuf, len=-1):
        return _Sword.SWModule_setEntry(self, inbuf, len)

    def linkEntry(self, sourceKey):
        return _Sword.SWModule_linkEntry(self, sourceKey)

    def deleteEntry(self):
        return _Sword.SWModule_deleteEntry(self)

    def decrement(self, steps=1):
        return _Sword.SWModule_decrement(self, steps)

    def increment(self, steps=1):
        return _Sword.SWModule_increment(self, steps)

    def setPosition(self, pos):
        return _Sword.SWModule_setPosition(self, pos)

    def addRenderFilter(self, newFilter):
        return _Sword.SWModule_addRenderFilter(self, newFilter)

    def getRenderFilters(self):
        return _Sword.SWModule_getRenderFilters(self)

    def removeRenderFilter(self, oldFilter):
        return _Sword.SWModule_removeRenderFilter(self, oldFilter)

    def replaceRenderFilter(self, oldFilter, newFilter):
        return _Sword.SWModule_replaceRenderFilter(self, oldFilter, newFilter)

    def renderFilter(self, buf, key):
        return _Sword.SWModule_renderFilter(self, buf, key)

    def addEncodingFilter(self, newFilter):
        return _Sword.SWModule_addEncodingFilter(self, newFilter)

    def removeEncodingFilter(self, oldFilter):
        return _Sword.SWModule_removeEncodingFilter(self, oldFilter)

    def replaceEncodingFilter(self, oldFilter, newFilter):
        return _Sword.SWModule_replaceEncodingFilter(self, oldFilter, newFilter)

    def encodingFilter(self, buf, key):
        return _Sword.SWModule_encodingFilter(self, buf, key)

    def addStripFilter(self, newFilter):
        return _Sword.SWModule_addStripFilter(self, newFilter)

    def addRawFilter(self, newFilter):
        return _Sword.SWModule_addRawFilter(self, newFilter)

    def stripFilter(self, buf, key):
        return _Sword.SWModule_stripFilter(self, buf, key)

    def rawFilter(self, buf, key):
        return _Sword.SWModule_rawFilter(self, buf, key)

    def addOptionFilter(self, newFilter):
        return _Sword.SWModule_addOptionFilter(self, newFilter)

    def getOptionFilters(self):
        return _Sword.SWModule_getOptionFilters(self)

    def optionFilter(self, buf, key):
        return _Sword.SWModule_optionFilter(self, buf, key)

    def getRenderHeader(self):
        return _Sword.SWModule_getRenderHeader(self)

    def stripText(self, *args):
        return _Sword.SWModule_stripText(self, *args)

    def renderText(self, *args):
        return _Sword.SWModule_renderText(self, *args)

    def setSkipConsecutiveLinks(self, val):
        return _Sword.SWModule_setSkipConsecutiveLinks(self, val)

    def isSkipConsecutiveLinks(self):
        return _Sword.SWModule_isSkipConsecutiveLinks(self)

    def isLinked(self, arg2, arg3):
        return _Sword.SWModule_isLinked(self, arg2, arg3)

    def hasEntry(self, arg2):
        return _Sword.SWModule_hasEntry(self, arg2)

    def setProcessEntryAttributes(self, val):
        return _Sword.SWModule_setProcessEntryAttributes(self, val)

    def isProcessEntryAttributes(self):
        return _Sword.SWModule_isProcessEntryAttributes(self)

    def deleteSearchFramework(self):
        return _Sword.SWModule_deleteSearchFramework(self)

    def hasSearchFramework(self):
        return _Sword.SWModule_hasSearchFramework(self)

    def __lshift__(self, *args):
        return _Sword.SWModule___lshift__(self, *args)

    def __isub__(self, steps):
        return _Sword.SWModule___isub__(self, steps)

    def __iadd__(self, steps):
        return _Sword.SWModule___iadd__(self, steps)

    @staticmethod
    def castTo(o):
        return _Sword.SWModule_castTo(o)

    def getEntryAttributesMap(self):
        return _Sword.SWModule_getEntryAttributesMap(self)

    def getConfigMap(self):
        return _Sword.SWModule_getConfigMap(self)

# Register SWModule in _Sword:
_Sword.SWModule_swigregister(SWModule)
class SWMgr(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    MODTYPE_BIBLES = property(_Sword.SWMgr_MODTYPE_BIBLES_get, _Sword.SWMgr_MODTYPE_BIBLES_set)
    MODTYPE_COMMENTARIES = property(_Sword.SWMgr_MODTYPE_COMMENTARIES_get, _Sword.SWMgr_MODTYPE_COMMENTARIES_set)
    MODTYPE_LEXDICTS = property(_Sword.SWMgr_MODTYPE_LEXDICTS_get, _Sword.SWMgr_MODTYPE_LEXDICTS_set)
    MODTYPE_GENBOOKS = property(_Sword.SWMgr_MODTYPE_GENBOOKS_get, _Sword.SWMgr_MODTYPE_GENBOOKS_set)
    MODTYPE_DAILYDEVOS = property(_Sword.SWMgr_MODTYPE_DAILYDEVOS_get, _Sword.SWMgr_MODTYPE_DAILYDEVOS_set)
    isICU = property(_Sword.SWMgr_isICU_get, _Sword.SWMgr_isICU_set)
    globalConfPath = property(_Sword.SWMgr_globalConfPath_get, _Sword.SWMgr_globalConfPath_set)
    config = property(_Sword.SWMgr_config_get, _Sword.SWMgr_config_set)
    sysConfig = property(_Sword.SWMgr_sysConfig_get, _Sword.SWMgr_sysConfig_set)
    prefixPath = property(_Sword.SWMgr_prefixPath_get, _Sword.SWMgr_prefixPath_set)
    configPath = property(_Sword.SWMgr_configPath_get, _Sword.SWMgr_configPath_set)

    def getModules(self, *args):
        return _Sword.SWMgr_getModules(self, *args)

    def getUtilModules(self, *args):
        return _Sword.SWMgr_getUtilModules(self, *args)

    def getModule(self, *args):
        return _Sword.SWMgr_getModule(self, *args)

    def __init__(self, *args):
        _Sword.SWMgr_swiginit(self, _Sword.new_SWMgr(*args))
    __swig_destroy__ = _Sword.delete_SWMgr

    def augmentModules(self, path, multiMod=False):
        return _Sword.SWMgr_augmentModules(self, path, multiMod)

    def deleteModule(self, arg2):
        return _Sword.SWMgr_deleteModule(self, arg2)

    def InstallScan(self, dir):
        return _Sword.SWMgr_InstallScan(self, dir)

    def load(self):
        return _Sword.SWMgr_load(self)

    def setGlobalOption(self, option, value):
        return _Sword.SWMgr_setGlobalOption(self, option, value)

    def getGlobalOption(self, option):
        return _Sword.SWMgr_getGlobalOption(self, option)

    def getGlobalOptionTip(self, option):
        return _Sword.SWMgr_getGlobalOptionTip(self, option)

    def getGlobalOptions(self):
        return _Sword.SWMgr_getGlobalOptions(self)

    def getGlobalOptionValues(self, option):
        return _Sword.SWMgr_getGlobalOptionValues(self, option)

    def filterText(self, filterName, text, key=None, module=None):
        return _Sword.SWMgr_filterText(self, filterName, text, key, module)

    def setCipherKey(self, modName, key):
        return _Sword.SWMgr_setCipherKey(self, modName, key)

    def getGlobalOptionsVector(self):
        return _Sword.SWMgr_getGlobalOptionsVector(self)

    def getGlobalOptionValuesVector(self, option):
        return _Sword.SWMgr_getGlobalOptionValuesVector(self, option)

    def getModuleAt(self, pos):
        return _Sword.SWMgr_getModuleAt(self, pos)

# Register SWMgr in _Sword:
_Sword.SWMgr_swigregister(SWMgr)
class DirEntry(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    name = property(_Sword.DirEntry_name_get, _Sword.DirEntry_name_set)
    size = property(_Sword.DirEntry_size_get, _Sword.DirEntry_size_set)
    isDirectory = property(_Sword.DirEntry_isDirectory_get, _Sword.DirEntry_isDirectory_set)

    def __init__(self):
        _Sword.DirEntry_swiginit(self, _Sword.new_DirEntry())
    __swig_destroy__ = _Sword.delete_DirEntry

# Register DirEntry in _Sword:
_Sword.DirEntry_swigregister(DirEntry)
class FileMgr(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    CREAT = property(_Sword.FileMgr_CREAT_get, _Sword.FileMgr_CREAT_set)
    APPEND = property(_Sword.FileMgr_APPEND_get, _Sword.FileMgr_APPEND_set)
    TRUNC = property(_Sword.FileMgr_TRUNC_get, _Sword.FileMgr_TRUNC_set)
    RDONLY = property(_Sword.FileMgr_RDONLY_get, _Sword.FileMgr_RDONLY_set)
    RDWR = property(_Sword.FileMgr_RDWR_get, _Sword.FileMgr_RDWR_set)
    WRONLY = property(_Sword.FileMgr_WRONLY_get, _Sword.FileMgr_WRONLY_set)
    IREAD = property(_Sword.FileMgr_IREAD_get, _Sword.FileMgr_IREAD_set)
    IWRITE = property(_Sword.FileMgr_IWRITE_get, _Sword.FileMgr_IWRITE_set)
    maxFiles = property(_Sword.FileMgr_maxFiles_get, _Sword.FileMgr_maxFiles_set)

    @staticmethod
    def getSystemFileMgr():
        return _Sword.FileMgr_getSystemFileMgr()

    @staticmethod
    def setSystemFileMgr(newFileMgr):
        return _Sword.FileMgr_setSystemFileMgr(newFileMgr)

    def __init__(self, maxFiles=35):
        _Sword.FileMgr_swiginit(self, _Sword.new_FileMgr(maxFiles))
    __swig_destroy__ = _Sword.delete_FileMgr

    def open(self, *args):
        return _Sword.FileMgr_open(self, *args)

    def close(self, file):
        return _Sword.FileMgr_close(self, file)

    def flush(self):
        return _Sword.FileMgr_flush(self)

    def resourceConsumption(self):
        return _Sword.FileMgr_resourceConsumption(self)

    @staticmethod
    def getEnvValue(variableName):
        return _Sword.FileMgr_getEnvValue(variableName)

    @staticmethod
    def hasAccess(path, mode):
        return _Sword.FileMgr_hasAccess(path, mode)

    @staticmethod
    def existsFile(ipath, ifileName=None):
        return _Sword.FileMgr_existsFile(ipath, ifileName)

    @staticmethod
    def existsDir(ipath, idirName=None):
        return _Sword.FileMgr_existsDir(ipath, idirName)

    @staticmethod
    def getDirList(dirPath, includeSize=False, includeIsDirectory=True):
        return _Sword.FileMgr_getDirList(dirPath, includeSize, includeIsDirectory)

    def trunc(self, file):
        return _Sword.FileMgr_trunc(self, file)

    @staticmethod
    def isDirectory(path):
        return _Sword.FileMgr_isDirectory(path)

    @staticmethod
    def getFileSize(path):
        return _Sword.FileMgr_getFileSize(path)

    @staticmethod
    def createParent(pName):
        return _Sword.FileMgr_createParent(pName)

    @staticmethod
    def createPathAndFile(fName):
        return _Sword.FileMgr_createPathAndFile(fName)

    @staticmethod
    def openFile(fName, mode, perms):
        return _Sword.FileMgr_openFile(fName, mode, perms)

    @staticmethod
    def openFileReadOnly(fName):
        return _Sword.FileMgr_openFileReadOnly(fName)

    @staticmethod
    def closeFile(fd):
        return _Sword.FileMgr_closeFile(fd)

    @staticmethod
    def write(fd, buf, count):
        return _Sword.FileMgr_write(fd, buf, count)

    @staticmethod
    def copyFile(srcFile, destFile):
        return _Sword.FileMgr_copyFile(srcFile, destFile)

    @staticmethod
    def copyDir(srcDir, destDir):
        return _Sword.FileMgr_copyDir(srcDir, destDir)

    @staticmethod
    def removeDir(targetDir):
        return _Sword.FileMgr_removeDir(targetDir)

    @staticmethod
    def removeFile(fName):
        return _Sword.FileMgr_removeFile(fName)

    @staticmethod
    def getLine(fDesc, line):
        return _Sword.FileMgr_getLine(fDesc, line)

    def getHomeDir(self):
        return _Sword.FileMgr_getHomeDir(self)

# Register FileMgr in _Sword:
_Sword.FileMgr_swigregister(FileMgr)
class FileDesc(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr

    def getFd(self):
        return _Sword.FileDesc_getFd(self)

    def seek(self, offset, whence):
        return _Sword.FileDesc_seek(self, offset, whence)

    def read(self, buf, count):
        return _Sword.FileDesc_read(self, buf, count)

    def write(self, buf, count):
        return _Sword.FileDesc_write(self, buf, count)
    path = property(_Sword.FileDesc_path_get, _Sword.FileDesc_path_set)
    mode = property(_Sword.FileDesc_mode_get, _Sword.FileDesc_mode_set)
    perms = property(_Sword.FileDesc_perms_get, _Sword.FileDesc_perms_set)
    tryDowngrade = property(_Sword.FileDesc_tryDowngrade_get, _Sword.FileDesc_tryDowngrade_set)

# Register FileDesc in _Sword:
_Sword.FileDesc_swigregister(FileDesc)
class EncodingFilterMgr(SWFilterMgr):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        _Sword.EncodingFilterMgr_swiginit(self, _Sword.new_EncodingFilterMgr(*args))
    __swig_destroy__ = _Sword.delete_EncodingFilterMgr

    def Encoding(self, enc):
        return _Sword.EncodingFilterMgr_Encoding(self, enc)

    def getEncoding(self):
        return _Sword.EncodingFilterMgr_getEncoding(self)

    def setEncoding(self, enc):
        return _Sword.EncodingFilterMgr_setEncoding(self, enc)

    def addRawFilters(self, module, section):
        return _Sword.EncodingFilterMgr_addRawFilters(self, module, section)

    def addEncodingFilters(self, module, section):
        return _Sword.EncodingFilterMgr_addEncodingFilters(self, module, section)

    @staticmethod
    def castTo(o):
        return _Sword.EncodingFilterMgr_castTo(o)

# Register EncodingFilterMgr in _Sword:
_Sword.EncodingFilterMgr_swigregister(EncodingFilterMgr)
class MarkupFilterMgr(EncodingFilterMgr):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        _Sword.MarkupFilterMgr_swiginit(self, _Sword.new_MarkupFilterMgr(*args))
    __swig_destroy__ = _Sword.delete_MarkupFilterMgr

    def Markup(self, *args):
        return _Sword.MarkupFilterMgr_Markup(self, *args)

    def getMarkup(self):
        return _Sword.MarkupFilterMgr_getMarkup(self)

    def setMarkup(self, m):
        return _Sword.MarkupFilterMgr_setMarkup(self, m)

    def addRenderFilters(self, module, section):
        return _Sword.MarkupFilterMgr_addRenderFilters(self, module, section)

    @staticmethod
    def castTo(o):
        return _Sword.MarkupFilterMgr_castTo(o)

# Register MarkupFilterMgr in _Sword:
_Sword.MarkupFilterMgr_swigregister(MarkupFilterMgr)
class SWLocale(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, ifilename):
        _Sword.SWLocale_swiginit(self, _Sword.new_SWLocale(ifilename))
    __swig_destroy__ = _Sword.delete_SWLocale

    def getName(self):
        return _Sword.SWLocale_getName(self)

    def getDescription(self):
        return _Sword.SWLocale_getDescription(self)

    def getEncoding(self):
        return _Sword.SWLocale_getEncoding(self)

    def translate(self, text):
        return _Sword.SWLocale_translate(self, text)

    def augment(self, addFrom):
        return _Sword.SWLocale_augment(self, addFrom)
    DEFAULT_LOCALE_NAME = property(_Sword.SWLocale_DEFAULT_LOCALE_NAME_get, _Sword.SWLocale_DEFAULT_LOCALE_NAME_set)

    def getBookAbbrevs(self):
        return _Sword.SWLocale_getBookAbbrevs(self)

# Register SWLocale in _Sword:
_Sword.SWLocale_swigregister(SWLocale)
ENDOFABBREVS = cvar.ENDOFABBREVS

class SWCompress(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self):
        _Sword.SWCompress_swiginit(self, _Sword.new_SWCompress())
    __swig_destroy__ = _Sword.delete_SWCompress

    def setUncompressedBuf(self, buf=None, len=None):
        return _Sword.SWCompress_setUncompressedBuf(self, buf, len)

    def getUncompressedBuf(self, len=None):
        return _Sword.SWCompress_getUncompressedBuf(self, len)

    def setCompressedBuf(self, len, buf=None):
        return _Sword.SWCompress_setCompressedBuf(self, len, buf)

    def getCompressedBuf(self, len=None):
        return _Sword.SWCompress_getCompressedBuf(self, len)

    def getChars(self, buf, len):
        return _Sword.SWCompress_getChars(self, buf, len)

    def sendChars(self, buf, len):
        return _Sword.SWCompress_sendChars(self, buf, len)

    def encode(self):
        return _Sword.SWCompress_encode(self)

    def decode(self):
        return _Sword.SWCompress_decode(self)

    def setLevel(self, l):
        return _Sword.SWCompress_setLevel(self, l)

    def getLevel(self):
        return _Sword.SWCompress_getLevel(self)

# Register SWCompress in _Sword:
_Sword.SWCompress_swigregister(SWCompress)
class LZSSCompress(SWCompress):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self):
        _Sword.LZSSCompress_swiginit(self, _Sword.new_LZSSCompress())
    __swig_destroy__ = _Sword.delete_LZSSCompress

    def encode(self):
        return _Sword.LZSSCompress_encode(self)

    def decode(self):
        return _Sword.LZSSCompress_decode(self)

    @staticmethod
    def castTo(o):
        return _Sword.LZSSCompress_castTo(o)

# Register LZSSCompress in _Sword:
_Sword.LZSSCompress_swigregister(LZSSCompress)
class ZipCompress(SWCompress):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self):
        _Sword.ZipCompress_swiginit(self, _Sword.new_ZipCompress())
    __swig_destroy__ = _Sword.delete_ZipCompress

    def encode(self):
        return _Sword.ZipCompress_encode(self)

    def decode(self):
        return _Sword.ZipCompress_decode(self)

    @staticmethod
    def unTarGZ(fd, destPath):
        return _Sword.ZipCompress_unTarGZ(fd, destPath)

    @staticmethod
    def castTo(o):
        return _Sword.ZipCompress_castTo(o)

# Register ZipCompress in _Sword:
_Sword.ZipCompress_swigregister(ZipCompress)
class SWCom(SWModule):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr
    __swig_destroy__ = _Sword.delete_SWCom

    def createKey(self):
        return _Sword.SWCom_createKey(self)

    def getIndex(self):
        return _Sword.SWCom_getIndex(self)

    def setIndex(self, iindex):
        return _Sword.SWCom_setIndex(self, iindex)

    def __lshift__(self, *args):
        return _Sword.SWCom___lshift__(self, *args)

    def __isub__(self, steps):
        return _Sword.SWCom___isub__(self, steps)

    def __iadd__(self, steps):
        return _Sword.SWCom___iadd__(self, steps)

    @staticmethod
    def castTo(o):
        return _Sword.SWCom_castTo(o)

# Register SWCom in _Sword:
_Sword.SWCom_swigregister(SWCom)
class RawCom(RawVerse, SWCom):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        _Sword.RawCom_swiginit(self, _Sword.new_RawCom(*args))
    __swig_destroy__ = _Sword.delete_RawCom

    def getRawEntryBuf(self):
        return _Sword.RawCom_getRawEntryBuf(self)

    def increment(self, steps=1):
        return _Sword.RawCom_increment(self, steps)

    def decrement(self, steps=1):
        return _Sword.RawCom_decrement(self, steps)

    def isWritable(self):
        return _Sword.RawCom_isWritable(self)

    @staticmethod
    def createModule(*args):
        return _Sword.RawCom_createModule(*args)

    def setEntry(self, inbuf, len=-1):
        return _Sword.RawCom_setEntry(self, inbuf, len)

    def linkEntry(self, linkKey):
        return _Sword.RawCom_linkEntry(self, linkKey)

    def deleteEntry(self):
        return _Sword.RawCom_deleteEntry(self)

    def isLinked(self, k1, k2):
        return _Sword.RawCom_isLinked(self, k1, k2)

    def hasEntry(self, k):
        return _Sword.RawCom_hasEntry(self, k)

    def __lshift__(self, *args):
        return _Sword.RawCom___lshift__(self, *args)

    def __isub__(self, steps):
        return _Sword.RawCom___isub__(self, steps)

    def __iadd__(self, steps):
        return _Sword.RawCom___iadd__(self, steps)

    @staticmethod
    def castTo(o):
        return _Sword.RawCom_castTo(o)

# Register RawCom in _Sword:
_Sword.RawCom_swigregister(RawCom)
class zCom(zVerse, SWCom):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        _Sword.zCom_swiginit(self, _Sword.new_zCom(*args))
    __swig_destroy__ = _Sword.delete_zCom

    def getRawEntryBuf(self):
        return _Sword.zCom_getRawEntryBuf(self)

    def increment(self, steps=1):
        return _Sword.zCom_increment(self, steps)

    def decrement(self, steps=1):
        return _Sword.zCom_decrement(self, steps)

    def isWritable(self):
        return _Sword.zCom_isWritable(self)

    @staticmethod
    def createModule(*args):
        return _Sword.zCom_createModule(*args)

    def setEntry(self, inbuf, len=-1):
        return _Sword.zCom_setEntry(self, inbuf, len)

    def linkEntry(self, linkKey):
        return _Sword.zCom_linkEntry(self, linkKey)

    def deleteEntry(self):
        return _Sword.zCom_deleteEntry(self)

    def rawZFilter(self, buf, direction=0):
        return _Sword.zCom_rawZFilter(self, buf, direction)

    def flush(self):
        return _Sword.zCom_flush(self)

    def isLinked(self, k1, k2):
        return _Sword.zCom_isLinked(self, k1, k2)

    def hasEntry(self, k):
        return _Sword.zCom_hasEntry(self, k)

    def __lshift__(self, *args):
        return _Sword.zCom___lshift__(self, *args)

    def __isub__(self, steps):
        return _Sword.zCom___isub__(self, steps)

    def __iadd__(self, steps):
        return _Sword.zCom___iadd__(self, steps)

    @staticmethod
    def castTo(o):
        return _Sword.zCom_castTo(o)

# Register zCom in _Sword:
_Sword.zCom_swigregister(zCom)
class SWGenBook(SWModule):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr
    __swig_destroy__ = _Sword.delete_SWGenBook

    def createKey(self):
        return _Sword.SWGenBook_createKey(self)

    def __lshift__(self, *args):
        return _Sword.SWGenBook___lshift__(self, *args)

    def __isub__(self, steps):
        return _Sword.SWGenBook___isub__(self, steps)

    def __iadd__(self, steps):
        return _Sword.SWGenBook___iadd__(self, steps)

    @staticmethod
    def castTo(o):
        return _Sword.SWGenBook_castTo(o)

# Register SWGenBook in _Sword:
_Sword.SWGenBook_swigregister(SWGenBook)
class RawGenBook(SWGenBook):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        _Sword.RawGenBook_swiginit(self, _Sword.new_RawGenBook(*args))
    __swig_destroy__ = _Sword.delete_RawGenBook

    def getRawEntryBuf(self):
        return _Sword.RawGenBook_getRawEntryBuf(self)

    def isWritable(self):
        return _Sword.RawGenBook_isWritable(self)

    @staticmethod
    def createModule(ipath):
        return _Sword.RawGenBook_createModule(ipath)

    def setEntry(self, inbuf, len=-1):
        return _Sword.RawGenBook_setEntry(self, inbuf, len)

    def linkEntry(self, linkKey):
        return _Sword.RawGenBook_linkEntry(self, linkKey)

    def deleteEntry(self):
        return _Sword.RawGenBook_deleteEntry(self)

    def createKey(self):
        return _Sword.RawGenBook_createKey(self)

    def hasEntry(self, k):
        return _Sword.RawGenBook_hasEntry(self, k)

    def __lshift__(self, *args):
        return _Sword.RawGenBook___lshift__(self, *args)

    def __isub__(self, steps):
        return _Sword.RawGenBook___isub__(self, steps)

    def __iadd__(self, steps):
        return _Sword.RawGenBook___iadd__(self, steps)

    @staticmethod
    def castTo(o):
        return _Sword.RawGenBook_castTo(o)

# Register RawGenBook in _Sword:
_Sword.RawGenBook_swigregister(RawGenBook)
class SWLD(SWModule):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr
    __swig_destroy__ = _Sword.delete_SWLD

    def createKey(self):
        return _Sword.SWLD_createKey(self)

    def getKeyText(self):
        return _Sword.SWLD_getKeyText(self)

    def setPosition(self, pos):
        return _Sword.SWLD_setPosition(self, pos)

    def getEntryCount(self):
        return _Sword.SWLD_getEntryCount(self)

    def getEntryForKey(self, key):
        return _Sword.SWLD_getEntryForKey(self, key)

    def getKeyForEntry(self, entry):
        return _Sword.SWLD_getKeyForEntry(self, entry)

    def hasEntry(self, k):
        return _Sword.SWLD_hasEntry(self, k)

    def __lshift__(self, *args):
        return _Sword.SWLD___lshift__(self, *args)

    def __isub__(self, steps):
        return _Sword.SWLD___isub__(self, steps)

    def __iadd__(self, steps):
        return _Sword.SWLD___iadd__(self, steps)

    @staticmethod
    def castTo(o):
        return _Sword.SWLD_castTo(o)

# Register SWLD in _Sword:
_Sword.SWLD_swigregister(SWLD)
class RawLD(RawStr, SWLD):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        _Sword.RawLD_swiginit(self, _Sword.new_RawLD(*args))
    __swig_destroy__ = _Sword.delete_RawLD

    def getRawEntryBuf(self):
        return _Sword.RawLD_getRawEntryBuf(self)

    def increment(self, steps=1):
        return _Sword.RawLD_increment(self, steps)

    def decrement(self, steps=1):
        return _Sword.RawLD_decrement(self, steps)

    def isWritable(self):
        return _Sword.RawLD_isWritable(self)

    @staticmethod
    def createModule(path):
        return _Sword.RawLD_createModule(path)

    def setEntry(self, inbuf, len=-1):
        return _Sword.RawLD_setEntry(self, inbuf, len)

    def linkEntry(self, linkKey):
        return _Sword.RawLD_linkEntry(self, linkKey)

    def deleteEntry(self):
        return _Sword.RawLD_deleteEntry(self)

    def getEntryCount(self):
        return _Sword.RawLD_getEntryCount(self)

    def getEntryForKey(self, key):
        return _Sword.RawLD_getEntryForKey(self, key)

    def getKeyForEntry(self, entry):
        return _Sword.RawLD_getKeyForEntry(self, entry)

    def __lshift__(self, *args):
        return _Sword.RawLD___lshift__(self, *args)

    def __isub__(self, steps):
        return _Sword.RawLD___isub__(self, steps)

    def __iadd__(self, steps):
        return _Sword.RawLD___iadd__(self, steps)

    @staticmethod
    def castTo(o):
        return _Sword.RawLD_castTo(o)

# Register RawLD in _Sword:
_Sword.RawLD_swigregister(RawLD)
class RawLD4(RawStr4, SWLD):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        _Sword.RawLD4_swiginit(self, _Sword.new_RawLD4(*args))
    __swig_destroy__ = _Sword.delete_RawLD4

    def getRawEntryBuf(self):
        return _Sword.RawLD4_getRawEntryBuf(self)

    def increment(self, steps=1):
        return _Sword.RawLD4_increment(self, steps)

    def decrement(self, steps=1):
        return _Sword.RawLD4_decrement(self, steps)

    def isWritable(self):
        return _Sword.RawLD4_isWritable(self)

    @staticmethod
    def createModule(path):
        return _Sword.RawLD4_createModule(path)

    def setEntry(self, inbuf, len=-1):
        return _Sword.RawLD4_setEntry(self, inbuf, len)

    def linkEntry(self, linkKey):
        return _Sword.RawLD4_linkEntry(self, linkKey)

    def deleteEntry(self):
        return _Sword.RawLD4_deleteEntry(self)

    def getEntryCount(self):
        return _Sword.RawLD4_getEntryCount(self)

    def getEntryForKey(self, key):
        return _Sword.RawLD4_getEntryForKey(self, key)

    def getKeyForEntry(self, entry):
        return _Sword.RawLD4_getKeyForEntry(self, entry)

    def __lshift__(self, *args):
        return _Sword.RawLD4___lshift__(self, *args)

    def __isub__(self, steps):
        return _Sword.RawLD4___isub__(self, steps)

    def __iadd__(self, steps):
        return _Sword.RawLD4___iadd__(self, steps)

    @staticmethod
    def castTo(o):
        return _Sword.RawLD4_castTo(o)

# Register RawLD4 in _Sword:
_Sword.RawLD4_swigregister(RawLD4)
class zLD(zStr, SWLD):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        _Sword.zLD_swiginit(self, _Sword.new_zLD(*args))
    __swig_destroy__ = _Sword.delete_zLD

    def getRawEntryBuf(self):
        return _Sword.zLD_getRawEntryBuf(self)

    def increment(self, steps=1):
        return _Sword.zLD_increment(self, steps)

    def decrement(self, steps=1):
        return _Sword.zLD_decrement(self, steps)

    def isWritable(self):
        return _Sword.zLD_isWritable(self)

    @staticmethod
    def createModule(path):
        return _Sword.zLD_createModule(path)

    def setEntry(self, inbuf, len=-1):
        return _Sword.zLD_setEntry(self, inbuf, len)

    def linkEntry(self, linkKey):
        return _Sword.zLD_linkEntry(self, linkKey)

    def deleteEntry(self):
        return _Sword.zLD_deleteEntry(self)

    def rawZFilter(self, buf, direction=0):
        return _Sword.zLD_rawZFilter(self, buf, direction)

    def flush(self):
        return _Sword.zLD_flush(self)

    def getEntryCount(self):
        return _Sword.zLD_getEntryCount(self)

    def getEntryForKey(self, key):
        return _Sword.zLD_getEntryForKey(self, key)

    def getKeyForEntry(self, entry):
        return _Sword.zLD_getKeyForEntry(self, entry)

    def __lshift__(self, *args):
        return _Sword.zLD___lshift__(self, *args)

    def __isub__(self, steps):
        return _Sword.zLD___isub__(self, steps)

    def __iadd__(self, steps):
        return _Sword.zLD___iadd__(self, steps)

    @staticmethod
    def castTo(o):
        return _Sword.zLD_castTo(o)

# Register zLD in _Sword:
_Sword.zLD_swigregister(zLD)
class SWText(SWModule):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr
    __swig_destroy__ = _Sword.delete_SWText

    def createKey(self):
        return _Sword.SWText_createKey(self)

    def getIndex(self):
        return _Sword.SWText_getIndex(self)

    def setIndex(self, iindex):
        return _Sword.SWText_setIndex(self, iindex)

    def __lshift__(self, *args):
        return _Sword.SWText___lshift__(self, *args)

    def __isub__(self, steps):
        return _Sword.SWText___isub__(self, steps)

    def __iadd__(self, steps):
        return _Sword.SWText___iadd__(self, steps)

    @staticmethod
    def castTo(o):
        return _Sword.SWText_castTo(o)

# Register SWText in _Sword:
_Sword.SWText_swigregister(SWText)
class RawText(SWText, RawVerse):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        _Sword.RawText_swiginit(self, _Sword.new_RawText(*args))
    __swig_destroy__ = _Sword.delete_RawText

    def getRawEntryBuf(self):
        return _Sword.RawText_getRawEntryBuf(self)

    def increment(self, steps=1):
        return _Sword.RawText_increment(self, steps)

    def decrement(self, steps=1):
        return _Sword.RawText_decrement(self, steps)

    def isWritable(self):
        return _Sword.RawText_isWritable(self)

    @staticmethod
    def createModule(*args):
        return _Sword.RawText_createModule(*args)

    def setEntry(self, inbuf, len=-1):
        return _Sword.RawText_setEntry(self, inbuf, len)

    def linkEntry(self, linkKey):
        return _Sword.RawText_linkEntry(self, linkKey)

    def deleteEntry(self):
        return _Sword.RawText_deleteEntry(self)

    def isLinked(self, k1, k2):
        return _Sword.RawText_isLinked(self, k1, k2)

    def hasEntry(self, k):
        return _Sword.RawText_hasEntry(self, k)

    def __lshift__(self, *args):
        return _Sword.RawText___lshift__(self, *args)

    def __isub__(self, steps):
        return _Sword.RawText___isub__(self, steps)

    def __iadd__(self, steps):
        return _Sword.RawText___iadd__(self, steps)

    @staticmethod
    def castTo(o):
        return _Sword.RawText_castTo(o)

# Register RawText in _Sword:
_Sword.RawText_swigregister(RawText)
class zText(zVerse, SWText):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        _Sword.zText_swiginit(self, _Sword.new_zText(*args))
    __swig_destroy__ = _Sword.delete_zText

    def getRawEntryBuf(self):
        return _Sword.zText_getRawEntryBuf(self)

    def increment(self, steps=1):
        return _Sword.zText_increment(self, steps)

    def decrement(self, steps=1):
        return _Sword.zText_decrement(self, steps)

    def isWritable(self):
        return _Sword.zText_isWritable(self)

    @staticmethod
    def createModule(*args):
        return _Sword.zText_createModule(*args)

    def setEntry(self, inbuf, len=-1):
        return _Sword.zText_setEntry(self, inbuf, len)

    def linkEntry(self, linkKey):
        return _Sword.zText_linkEntry(self, linkKey)

    def deleteEntry(self):
        return _Sword.zText_deleteEntry(self)

    def rawZFilter(self, buf, direction=0):
        return _Sword.zText_rawZFilter(self, buf, direction)

    def flush(self):
        return _Sword.zText_flush(self)

    def isLinked(self, k1, k2):
        return _Sword.zText_isLinked(self, k1, k2)

    def hasEntry(self, k):
        return _Sword.zText_hasEntry(self, k)

    def __lshift__(self, *args):
        return _Sword.zText___lshift__(self, *args)

    def __isub__(self, steps):
        return _Sword.zText___isub__(self, steps)

    def __iadd__(self, steps):
        return _Sword.zText___iadd__(self, steps)

    @staticmethod
    def castTo(o):
        return _Sword.zText_castTo(o)

# Register zText in _Sword:
_Sword.zText_swigregister(zText)
class LocaleMgr(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, iConfigPath=None):
        _Sword.LocaleMgr_swiginit(self, _Sword.new_LocaleMgr(iConfigPath))
    __swig_destroy__ = _Sword.delete_LocaleMgr

    def getLocale(self, name):
        return _Sword.LocaleMgr_getLocale(self, name)

    def getAvailableLocales(self):
        return _Sword.LocaleMgr_getAvailableLocales(self)

    def translate(self, text, localeName=None):
        return _Sword.LocaleMgr_translate(self, text, localeName)

    def getDefaultLocaleName(self):
        return _Sword.LocaleMgr_getDefaultLocaleName(self)

    def setDefaultLocaleName(self, name):
        return _Sword.LocaleMgr_setDefaultLocaleName(self, name)

    @staticmethod
    def getSystemLocaleMgr():
        return _Sword.LocaleMgr_getSystemLocaleMgr()

    @staticmethod
    def setSystemLocaleMgr(newLocaleMgr):
        return _Sword.LocaleMgr_setSystemLocaleMgr(newLocaleMgr)

    def loadConfigDir(self, ipath):
        return _Sword.LocaleMgr_loadConfigDir(self, ipath)

    def getAvailableLocalesVector(self):
        return _Sword.LocaleMgr_getAvailableLocalesVector(self)

# Register LocaleMgr in _Sword:
_Sword.LocaleMgr_swigregister(LocaleMgr)
class URL(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, url):
        _Sword.URL_swiginit(self, _Sword.new_URL(url))

    def getProtocol(self):
        return _Sword.URL_getProtocol(self)

    def getHostName(self):
        return _Sword.URL_getHostName(self)

    def getPath(self):
        return _Sword.URL_getPath(self)

    def getParameters(self):
        return _Sword.URL_getParameters(self)

    def getParameterValue(self, name):
        return _Sword.URL_getParameterValue(self, name)

    @staticmethod
    def encode(urlText):
        return _Sword.URL_encode(urlText)

    @staticmethod
    def decode(encodedText):
        return _Sword.URL_decode(encodedText)
    __swig_destroy__ = _Sword.delete_URL

# Register URL in _Sword:
_Sword.URL_swigregister(URL)
class XMLTag(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        _Sword.XMLTag_swiginit(self, _Sword.new_XMLTag(*args))
    __swig_destroy__ = _Sword.delete_XMLTag

    def setText(self, tagString):
        return _Sword.XMLTag_setText(self, tagString)

    def getName(self):
        return _Sword.XMLTag_getName(self)

    def isEmpty(self):
        return _Sword.XMLTag_isEmpty(self)

    def setEmpty(self, value):
        return _Sword.XMLTag_setEmpty(self, value)

    def isEndTag(self, eID=None):
        return _Sword.XMLTag_isEndTag(self, eID)

    def setEndTag(self, value):
        return _Sword.XMLTag_setEndTag(self, value)

    def getAttributeNames(self):
        return _Sword.XMLTag_getAttributeNames(self)

    def getAttributePartCount(self, *args):
        return _Sword.XMLTag_getAttributePartCount(self, *args)

    def getAttribute(self, *args):
        return _Sword.XMLTag_getAttribute(self, *args)

    def setAttribute(self, *args):
        return _Sword.XMLTag_setAttribute(self, *args)

    def toString(self):
        return _Sword.XMLTag_toString(self)

# Register XMLTag in _Sword:
_Sword.XMLTag_swigregister(XMLTag)
class BasicFilterUserData(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, module, key):
        _Sword.BasicFilterUserData_swiginit(self, _Sword.new_BasicFilterUserData(module, key))
    __swig_destroy__ = _Sword.delete_BasicFilterUserData
    module = property(_Sword.BasicFilterUserData_module_get, _Sword.BasicFilterUserData_module_set)
    key = property(_Sword.BasicFilterUserData_key_get, _Sword.BasicFilterUserData_key_set)
    vkey = property(_Sword.BasicFilterUserData_vkey_get, _Sword.BasicFilterUserData_vkey_set)
    lastTextNode = property(_Sword.BasicFilterUserData_lastTextNode_get, _Sword.BasicFilterUserData_lastTextNode_set)
    lastSuspendSegment = property(_Sword.BasicFilterUserData_lastSuspendSegment_get, _Sword.BasicFilterUserData_lastSuspendSegment_set)
    suspendTextPassThru = property(_Sword.BasicFilterUserData_suspendTextPassThru_get, _Sword.BasicFilterUserData_suspendTextPassThru_set)
    supressAdjacentWhitespace = property(_Sword.BasicFilterUserData_supressAdjacentWhitespace_get, _Sword.BasicFilterUserData_supressAdjacentWhitespace_set)

# Register BasicFilterUserData in _Sword:
_Sword.BasicFilterUserData_swigregister(BasicFilterUserData)
class SWBasicFilter(SWFilter):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self):
        _Sword.SWBasicFilter_swiginit(self, _Sword.new_SWBasicFilter())

    def processText(self, text, key=None, module=None):
        return _Sword.SWBasicFilter_processText(self, text, key, module)
    __swig_destroy__ = _Sword.delete_SWBasicFilter

# Register SWBasicFilter in _Sword:
_Sword.SWBasicFilter_swigregister(SWBasicFilter)
class OSISHTMLHREF(SWBasicFilter):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self):
        _Sword.OSISHTMLHREF_swiginit(self, _Sword.new_OSISHTMLHREF())

    def setMorphFirst(self, val=True):
        return _Sword.OSISHTMLHREF_setMorphFirst(self, val)

    def setRenderNoteNumbers(self, val=True):
        return _Sword.OSISHTMLHREF_setRenderNoteNumbers(self, val)
    __swig_destroy__ = _Sword.delete_OSISHTMLHREF

# Register OSISHTMLHREF in _Sword:
_Sword.OSISHTMLHREF_swigregister(OSISHTMLHREF)
class ThMLHTMLHREF(SWBasicFilter):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self):
        _Sword.ThMLHTMLHREF_swiginit(self, _Sword.new_ThMLHTMLHREF())

    def getImagePrefix(self):
        return _Sword.ThMLHTMLHREF_getImagePrefix(self)

    def setImagePrefix(self, newImgPrefix):
        return _Sword.ThMLHTMLHREF_setImagePrefix(self, newImgPrefix)

    def setRenderNoteNumbers(self, val=True):
        return _Sword.ThMLHTMLHREF_setRenderNoteNumbers(self, val)
    __swig_destroy__ = _Sword.delete_ThMLHTMLHREF

# Register ThMLHTMLHREF in _Sword:
_Sword.ThMLHTMLHREF_swigregister(ThMLHTMLHREF)
class GBFHTMLHREF(SWBasicFilter):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self):
        _Sword.GBFHTMLHREF_swiginit(self, _Sword.new_GBFHTMLHREF())

    def setRenderNoteNumbers(self, val=True):
        return _Sword.GBFHTMLHREF_setRenderNoteNumbers(self, val)
    __swig_destroy__ = _Sword.delete_GBFHTMLHREF

# Register GBFHTMLHREF in _Sword:
_Sword.GBFHTMLHREF_swigregister(GBFHTMLHREF)
class UTF8HTML(SWFilter):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self):
        _Sword.UTF8HTML_swiginit(self, _Sword.new_UTF8HTML())

    def processText(self, text, key=None, module=None):
        return _Sword.UTF8HTML_processText(self, text, key, module)
    __swig_destroy__ = _Sword.delete_UTF8HTML

# Register UTF8HTML in _Sword:
_Sword.UTF8HTML_swigregister(UTF8HTML)
class MarkupCallback(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    __swig_destroy__ = _Sword.delete_MarkupCallback

    def run(self, x):
        return _Sword.MarkupCallback_run(self, x)

    def __init__(self):
        if self.__class__ == MarkupCallback:
            _self = None
        else:
            _self = self
        _Sword.MarkupCallback_swiginit(self, _Sword.new_MarkupCallback(_self, ))
    def __disown__(self):
        self.this.disown()
        _Sword.disown_MarkupCallback(self)
        return weakref.proxy(self)

# Register MarkupCallback in _Sword:
_Sword.MarkupCallback_swigregister(MarkupCallback)
class MyMarkup(MarkupFilterMgr):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        _Sword.MyMarkup_swiginit(self, _Sword.new_MyMarkup(*args))
    __swig_destroy__ = _Sword.delete_MyMarkup

    def delCallback(self):
        return _Sword.MyMarkup_delCallback(self)

    def setCallback(self, cb):
        return _Sword.MyMarkup_setCallback(self, cb)

    def call(self, x):
        return _Sword.MyMarkup_call(self, x)

# Register MyMarkup in _Sword:
_Sword.MyMarkup_swigregister(MyMarkup)
FAILED = _Sword.FAILED
SUCCEEDED = _Sword.SUCCEEDED
INHERITED = _Sword.INHERITED
class ReturnSuccess(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        _Sword.ReturnSuccess_swiginit(self, _Sword.new_ReturnSuccess(*args))
    __swig_destroy__ = _Sword.delete_ReturnSuccess
    data = property(_Sword.ReturnSuccess_data_get, _Sword.ReturnSuccess_data_set)
    success = property(_Sword.ReturnSuccess_success_get, _Sword.ReturnSuccess_success_set)

# Register ReturnSuccess in _Sword:
_Sword.ReturnSuccess_swigregister(ReturnSuccess)
class RenderCallback(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    __swig_destroy__ = _Sword.delete_RenderCallback

    def run(self, x, token, userData):
        return _Sword.RenderCallback_run(self, x, token, userData)

    def __init__(self):
        if self.__class__ == RenderCallback:
            _self = None
        else:
            _self = self
        _Sword.RenderCallback_swiginit(self, _Sword.new_RenderCallback(_self, ))
    def __disown__(self):
        self.this.disown()
        _Sword.disown_RenderCallback(self)
        return weakref.proxy(self)

# Register RenderCallback in _Sword:
_Sword.RenderCallback_swigregister(RenderCallback)
class PyOSISHTMLHREF(OSISHTMLHREF):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def removeTokenSubstitute(self, findString):
        return _Sword.PyOSISHTMLHREF_removeTokenSubstitute(self, findString)

    def addTokenSubstitute(self, findString, replaceString):
        return _Sword.PyOSISHTMLHREF_addTokenSubstitute(self, findString, replaceString)

    def addAllowedEscapeString(self, findString):
        return _Sword.PyOSISHTMLHREF_addAllowedEscapeString(self, findString)

    def removeAllowedEscapeString(self, findString):
        return _Sword.PyOSISHTMLHREF_removeAllowedEscapeString(self, findString)

    def __init__(self, callback):
        _Sword.PyOSISHTMLHREF_swiginit(self, _Sword.new_PyOSISHTMLHREF(callback))

    @staticmethod
    def getData(f):
        return _Sword.PyOSISHTMLHREF_getData(f)
    __swig_destroy__ = _Sword.delete_PyOSISHTMLHREF

    def delCallback(self):
        return _Sword.PyOSISHTMLHREF_delCallback(self)

    def setCallback(self, cb):
        return _Sword.PyOSISHTMLHREF_setCallback(self, cb)

    def call(self, buf, token, userData):
        return _Sword.PyOSISHTMLHREF_call(self, buf, token, userData)

# Register PyOSISHTMLHREF in _Sword:
_Sword.PyOSISHTMLHREF_swigregister(PyOSISHTMLHREF)
class PyThMLHTMLHREF(ThMLHTMLHREF):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def removeTokenSubstitute(self, findString):
        return _Sword.PyThMLHTMLHREF_removeTokenSubstitute(self, findString)

    def addTokenSubstitute(self, findString, replaceString):
        return _Sword.PyThMLHTMLHREF_addTokenSubstitute(self, findString, replaceString)

    def addAllowedEscapeString(self, findString):
        return _Sword.PyThMLHTMLHREF_addAllowedEscapeString(self, findString)

    def removeAllowedEscapeString(self, findString):
        return _Sword.PyThMLHTMLHREF_removeAllowedEscapeString(self, findString)

    def __init__(self, callback):
        _Sword.PyThMLHTMLHREF_swiginit(self, _Sword.new_PyThMLHTMLHREF(callback))

    @staticmethod
    def getData(f):
        return _Sword.PyThMLHTMLHREF_getData(f)
    __swig_destroy__ = _Sword.delete_PyThMLHTMLHREF

    def delCallback(self):
        return _Sword.PyThMLHTMLHREF_delCallback(self)

    def setCallback(self, cb):
        return _Sword.PyThMLHTMLHREF_setCallback(self, cb)

    def call(self, buf, token, userData):
        return _Sword.PyThMLHTMLHREF_call(self, buf, token, userData)

# Register PyThMLHTMLHREF in _Sword:
_Sword.PyThMLHTMLHREF_swigregister(PyThMLHTMLHREF)
class OSISData(BasicFilterUserData):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    osisQToTick = property(_Sword.OSISData_osisQToTick_get, _Sword.OSISData_osisQToTick_set)
    inBold = property(_Sword.OSISData_inBold_get, _Sword.OSISData_inBold_set)
    inXRefNote = property(_Sword.OSISData_inXRefNote_get, _Sword.OSISData_inXRefNote_set)
    isBiblicalText = property(_Sword.OSISData_isBiblicalText_get, _Sword.OSISData_isBiblicalText_set)
    suspendLevel = property(_Sword.OSISData_suspendLevel_get, _Sword.OSISData_suspendLevel_set)
    wordsOfChristStart = property(_Sword.OSISData_wordsOfChristStart_get, _Sword.OSISData_wordsOfChristStart_set)
    wordsOfChristEnd = property(_Sword.OSISData_wordsOfChristEnd_get, _Sword.OSISData_wordsOfChristEnd_set)
    lastTransChange = property(_Sword.OSISData_lastTransChange_get, _Sword.OSISData_lastTransChange_set)
    w = property(_Sword.OSISData_w_get, _Sword.OSISData_w_set)
    fn = property(_Sword.OSISData_fn_get, _Sword.OSISData_fn_set)
    version = property(_Sword.OSISData_version_get, _Sword.OSISData_version_set)
    __swig_destroy__ = _Sword.delete_OSISData

# Register OSISData in _Sword:
_Sword.OSISData_swigregister(OSISData)
class ThMLData(BasicFilterUserData):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    inscriptRef = property(_Sword.ThMLData_inscriptRef_get, _Sword.ThMLData_inscriptRef_set)
    inSecHead = property(_Sword.ThMLData_inSecHead_get, _Sword.ThMLData_inSecHead_set)
    isBiblicalText = property(_Sword.ThMLData_isBiblicalText_get, _Sword.ThMLData_isBiblicalText_set)
    version = property(_Sword.ThMLData_version_get, _Sword.ThMLData_version_set)
    startTag = property(_Sword.ThMLData_startTag_get, _Sword.ThMLData_startTag_set)
    __swig_destroy__ = _Sword.delete_ThMLData

# Register ThMLData in _Sword:
_Sword.ThMLData_swigregister(ThMLData)
class SWSearcher(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    mod = property(_Sword.SWSearcher_mod_get, _Sword.SWSearcher_mod_set)
    percent = property(_Sword.SWSearcher_percent_get, _Sword.SWSearcher_percent_set)

    @staticmethod
    def Callback(status, me):
        return _Sword.SWSearcher_Callback(status, me)

    def PercentFunction(self, value):
        return _Sword.SWSearcher_PercentFunction(self, value)

    def __init__(self, Mod):
        if self.__class__ == SWSearcher:
            _self = None
        else:
            _self = self
        _Sword.SWSearcher_swiginit(self, _Sword.new_SWSearcher(_self, Mod))
    __swig_destroy__ = _Sword.delete_SWSearcher

    def GetPercent(self):
        return _Sword.SWSearcher_GetPercent(self)

    def isSearchSupported(self, istr, searchType=0, flags=0, scope=None):
        return _Sword.SWSearcher_isSearchSupported(self, istr, searchType, flags, scope)

    def doSearch(self, istr, searchType=0, flags=0, scope=None):
        return _Sword.SWSearcher_doSearch(self, istr, searchType, flags, scope)

    def TerminateSearch(self):
        return _Sword.SWSearcher_TerminateSearch(self)
    def __disown__(self):
        self.this.disown()
        _Sword.disown_SWSearcher(self)
        return weakref.proxy(self)

# Register SWSearcher in _Sword:
_Sword.SWSearcher_swigregister(SWSearcher)
class SWLog(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    @staticmethod
    def getSystemLog():
        return _Sword.SWLog_getSystemLog()

    @staticmethod
    def setSystemLog(newLogger):
        return _Sword.SWLog_setSystemLog(newLogger)

    def __init__(self):
        _Sword.SWLog_swiginit(self, _Sword.new_SWLog())
    __swig_destroy__ = _Sword.delete_SWLog

    def setLogLevel(self, level):
        return _Sword.SWLog_setLogLevel(self, level)

    def getLogLevel(self):
        return _Sword.SWLog_getLogLevel(self)

    def logWarning(self, fmt):
        return _Sword.SWLog_logWarning(self, fmt)

    def logError(self, fmt):
        return _Sword.SWLog_logError(self, fmt)

    def logInformation(self, fmt):
        return _Sword.SWLog_logInformation(self, fmt)

    def logDebug(self, fmt):
        return _Sword.SWLog_logDebug(self, fmt)

    def logMessage(self, message, level):
        return _Sword.SWLog_logMessage(self, message, level)

    def logTimedInformation(self, fmt):
        return _Sword.SWLog_logTimedInformation(self, fmt)

# Register SWLog in _Sword:
_Sword.SWLog_swigregister(SWLog)
SWLog.LOG_ERROR = _Sword.cvar.SWLog_LOG_ERROR
SWLog.LOG_WARN = _Sword.cvar.SWLog_LOG_WARN
SWLog.LOG_INFO = _Sword.cvar.SWLog_LOG_INFO
SWLog.LOG_TIMEDINFO = _Sword.cvar.SWLog_LOG_TIMEDINFO
SWLog.LOG_DEBUG = _Sword.cvar.SWLog_LOG_DEBUG

class StatusReporter(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    __swig_destroy__ = _Sword.delete_StatusReporter

    def preStatus(self, totalBytes, completedBytes, message):
        return _Sword.StatusReporter_preStatus(self, totalBytes, completedBytes, message)

    def update(self, totalBytes, completedBytes):
        return _Sword.StatusReporter_update(self, totalBytes, completedBytes)

    def __init__(self):
        if self.__class__ == StatusReporter:
            _self = None
        else:
            _self = self
        _Sword.StatusReporter_swiginit(self, _Sword.new_StatusReporter(_self, ))
    def __disown__(self):
        self.this.disown()
        _Sword.disown_StatusReporter(self)
        return weakref.proxy(self)

# Register StatusReporter in _Sword:
_Sword.StatusReporter_swigregister(StatusReporter)
class RemoteTransport(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, host, statusReporter=None):
        _Sword.RemoteTransport_swiginit(self, _Sword.new_RemoteTransport(host, statusReporter))
    __swig_destroy__ = _Sword.delete_RemoteTransport

    def getURL(self, destPath, sourceURL, destBuf=None):
        return _Sword.RemoteTransport_getURL(self, destPath, sourceURL, destBuf)

    def putURL(self, destURL, sourcePath, sourceBuf=None):
        return _Sword.RemoteTransport_putURL(self, destURL, sourcePath, sourceBuf)

    def copyDirectory(self, urlPrefix, dir, dest, suffix):
        return _Sword.RemoteTransport_copyDirectory(self, urlPrefix, dir, dest, suffix)

    def getDirList(self, dirURL):
        return _Sword.RemoteTransport_getDirList(self, dirURL)

    def setPassive(self, passive):
        return _Sword.RemoteTransport_setPassive(self, passive)

    def setTimeoutMillis(self, timeoutMillis):
        return _Sword.RemoteTransport_setTimeoutMillis(self, timeoutMillis)

    def getTimeoutMillis(self):
        return _Sword.RemoteTransport_getTimeoutMillis(self)

    def isPassive(self):
        return _Sword.RemoteTransport_isPassive(self)

    def setUser(self, user):
        return _Sword.RemoteTransport_setUser(self, user)

    def setPasswd(self, passwd):
        return _Sword.RemoteTransport_setPasswd(self, passwd)

    def setUnverifiedPeerAllowed(self, val):
        return _Sword.RemoteTransport_setUnverifiedPeerAllowed(self, val)

    def isUnverifiedPeerAllowed(self):
        return _Sword.RemoteTransport_isUnverifiedPeerAllowed(self)

    def terminate(self):
        return _Sword.RemoteTransport_terminate(self)

# Register RemoteTransport in _Sword:
_Sword.RemoteTransport_swigregister(RemoteTransport)
class InstallSource(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, type, confEnt=None):
        _Sword.InstallSource_swiginit(self, _Sword.new_InstallSource(type, confEnt))
    __swig_destroy__ = _Sword.delete_InstallSource

    def getConfEnt(self):
        return _Sword.InstallSource_getConfEnt(self)
    caption = property(_Sword.InstallSource_caption_get, _Sword.InstallSource_caption_set)
    source = property(_Sword.InstallSource_source_get, _Sword.InstallSource_source_set)
    directory = property(_Sword.InstallSource_directory_get, _Sword.InstallSource_directory_set)
    u = property(_Sword.InstallSource_u_get, _Sword.InstallSource_u_set)
    p = property(_Sword.InstallSource_p_get, _Sword.InstallSource_p_set)
    uid = property(_Sword.InstallSource_uid_get, _Sword.InstallSource_uid_set)
    type = property(_Sword.InstallSource_type_get, _Sword.InstallSource_type_set)
    localShadow = property(_Sword.InstallSource_localShadow_get, _Sword.InstallSource_localShadow_set)

    def getMgr(self):
        return _Sword.InstallSource_getMgr(self)

    def flush(self):
        return _Sword.InstallSource_flush(self)

# Register InstallSource in _Sword:
_Sword.InstallSource_swigregister(InstallSource)
class InstallMgr(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    userDisclaimerConfirmed = property(_Sword.InstallMgr_userDisclaimerConfirmed_get, _Sword.InstallMgr_userDisclaimerConfirmed_set)
    installConf = property(_Sword.InstallMgr_installConf_get, _Sword.InstallMgr_installConf_set)
    sources = property(_Sword.InstallMgr_sources_get, _Sword.InstallMgr_sources_set)

    def __init__(self, *args):
        _Sword.InstallMgr_swiginit(self, _Sword.new_InstallMgr(*args))
    __swig_destroy__ = _Sword.delete_InstallMgr

    def readInstallConf(self):
        return _Sword.InstallMgr_readInstallConf(self)

    def saveInstallConf(self):
        return _Sword.InstallMgr_saveInstallConf(self)

    def clearSources(self):
        return _Sword.InstallMgr_clearSources(self)

    def removeModule(self, manager, modName):
        return _Sword.InstallMgr_removeModule(self, manager, modName)

    def remoteCopy(self, *args):
        return _Sword.InstallMgr_remoteCopy(self, *args)

    def installModule(self, destMgr, fromLocation, modName, _is=None):
        return _Sword.InstallMgr_installModule(self, destMgr, fromLocation, modName, _is)

    def refreshRemoteSource(self, _is):
        return _Sword.InstallMgr_refreshRemoteSource(self, _is)

    def refreshRemoteSourceConfiguration(self):
        return _Sword.InstallMgr_refreshRemoteSourceConfiguration(self)

    def isUserDisclaimerConfirmed(self):
        return _Sword.InstallMgr_isUserDisclaimerConfirmed(self)

    def setUserDisclaimerConfirmed(self, val):
        return _Sword.InstallMgr_setUserDisclaimerConfirmed(self, val)

    def getCipherCode(self, modName, config):
        return _Sword.InstallMgr_getCipherCode(self, modName, config)

    def setFTPPassive(self, passive):
        return _Sword.InstallMgr_setFTPPassive(self, passive)

    def isFTPPassive(self):
        return _Sword.InstallMgr_isFTPPassive(self)

    def setTimeoutMillis(self, timeoutMillis):
        return _Sword.InstallMgr_setTimeoutMillis(self, timeoutMillis)

    def getTimeoutMillis(self):
        return _Sword.InstallMgr_getTimeoutMillis(self)

    def setUnverifiedPeerAllowed(self, allowed):
        return _Sword.InstallMgr_setUnverifiedPeerAllowed(self, allowed)

    def isUnverifiedPeerAllowed(self):
        return _Sword.InstallMgr_isUnverifiedPeerAllowed(self)

    def terminate(self):
        return _Sword.InstallMgr_terminate(self)

    @staticmethod
    def getModuleStatus(base, other, utilModules=False):
        return _Sword.InstallMgr_getModuleStatus(base, other, utilModules)

    def isDefaultModule(self, modName):
        return _Sword.InstallMgr_isDefaultModule(self, modName)

# Register InstallMgr in _Sword:
_Sword.InstallMgr_swigregister(InstallMgr)
InstallMgr.MODSTAT_OLDER = _Sword.cvar.InstallMgr_MODSTAT_OLDER
InstallMgr.MODSTAT_SAMEVERSION = _Sword.cvar.InstallMgr_MODSTAT_SAMEVERSION
InstallMgr.MODSTAT_UPDATED = _Sword.cvar.InstallMgr_MODSTAT_UPDATED
InstallMgr.MODSTAT_NEW = _Sword.cvar.InstallMgr_MODSTAT_NEW
InstallMgr.MODSTAT_CIPHERED = _Sword.cvar.InstallMgr_MODSTAT_CIPHERED
InstallMgr.MODSTAT_CIPHERKEYPRESENT = _Sword.cvar.InstallMgr_MODSTAT_CIPHERKEYPRESENT


