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





from sys import version_info
if version_info >= (2, 6, 0):
    def swig_import_helper():
        from os.path import dirname
        import imp
        fp = None
        try:
            fp, pathname, description = imp.find_module('_Sword', [dirname(__file__)])
        except ImportError:
            import _Sword
            return _Sword
        if fp is not None:
            try:
                _mod = imp.load_module('_Sword', fp, pathname, description)
            finally:
                fp.close()
            return _mod
    _Sword = swig_import_helper()
    del swig_import_helper
else:
    import _Sword
del version_info
try:
    _swig_property = property
except NameError:
    pass  # Python < 2.2 doesn't have 'property'.


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


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


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

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


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

try:
    _object = object
    _newclass = 1
except AttributeError:
    class _object:
        pass
    _newclass = 0


try:
    import weakref
    weakref_proxy = weakref.proxy
except:
    weakref_proxy = lambda x: x



_Sword.DIRECTION_LTR_swigconstant(_Sword)
DIRECTION_LTR = _Sword.DIRECTION_LTR

_Sword.DIRECTION_RTL_swigconstant(_Sword)
DIRECTION_RTL = _Sword.DIRECTION_RTL

_Sword.DIRECTION_BIDI_swigconstant(_Sword)
DIRECTION_BIDI = _Sword.DIRECTION_BIDI

_Sword.FMT_UNKNOWN_swigconstant(_Sword)
FMT_UNKNOWN = _Sword.FMT_UNKNOWN

_Sword.FMT_PLAIN_swigconstant(_Sword)
FMT_PLAIN = _Sword.FMT_PLAIN

_Sword.FMT_THML_swigconstant(_Sword)
FMT_THML = _Sword.FMT_THML

_Sword.FMT_GBF_swigconstant(_Sword)
FMT_GBF = _Sword.FMT_GBF

_Sword.FMT_HTML_swigconstant(_Sword)
FMT_HTML = _Sword.FMT_HTML

_Sword.FMT_HTMLHREF_swigconstant(_Sword)
FMT_HTMLHREF = _Sword.FMT_HTMLHREF

_Sword.FMT_RTF_swigconstant(_Sword)
FMT_RTF = _Sword.FMT_RTF

_Sword.FMT_OSIS_swigconstant(_Sword)
FMT_OSIS = _Sword.FMT_OSIS

_Sword.FMT_WEBIF_swigconstant(_Sword)
FMT_WEBIF = _Sword.FMT_WEBIF

_Sword.FMT_TEI_swigconstant(_Sword)
FMT_TEI = _Sword.FMT_TEI

_Sword.FMT_XHTML_swigconstant(_Sword)
FMT_XHTML = _Sword.FMT_XHTML

_Sword.ENC_UNKNOWN_swigconstant(_Sword)
ENC_UNKNOWN = _Sword.ENC_UNKNOWN

_Sword.ENC_LATIN1_swigconstant(_Sword)
ENC_LATIN1 = _Sword.ENC_LATIN1

_Sword.ENC_UTF8_swigconstant(_Sword)
ENC_UTF8 = _Sword.ENC_UTF8

_Sword.ENC_SCSU_swigconstant(_Sword)
ENC_SCSU = _Sword.ENC_SCSU

_Sword.ENC_UTF16_swigconstant(_Sword)
ENC_UTF16 = _Sword.ENC_UTF16

_Sword.ENC_RTF_swigconstant(_Sword)
ENC_RTF = _Sword.ENC_RTF

_Sword.ENC_HTML_swigconstant(_Sword)
ENC_HTML = _Sword.ENC_HTML

_Sword.BIB_BIBTEX_swigconstant(_Sword)
BIB_BIBTEX = _Sword.BIB_BIBTEX

_Sword.JUNKBUFSIZE_swigconstant(_Sword)
JUNKBUFSIZE = _Sword.JUNKBUFSIZE
class SWBuf(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, SWBuf, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, SWBuf, name)
    __repr__ = _swig_repr
    __swig_setmethods__["nullStr"] = _Sword.SWBuf_nullStr_set
    __swig_getmethods__["nullStr"] = _Sword.SWBuf_nullStr_get
    if _newclass:
        nullStr = _swig_property(_Sword.SWBuf_nullStr_get, _Sword.SWBuf_nullStr_set)

    def __init__(self, *args):
        this = _Sword.new_SWBuf(*args)
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _Sword.delete_SWBuf
    __del__ = lambda self: None

    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 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 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)
SWBuf_swigregister = _Sword.SWBuf_swigregister
SWBuf_swigregister(SWBuf)
cvar = _Sword.cvar

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

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

    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
SwigPyIterator_swigregister = _Sword.SwigPyIterator_swigregister
SwigPyIterator_swigregister(SwigPyIterator)

class AttributeValueMap(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, AttributeValueMap, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, AttributeValueMap, name)
    __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):
        this = _Sword.new_AttributeValueMap(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

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

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

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

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

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

    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 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
    __del__ = lambda self: None
AttributeValueMap_swigregister = _Sword.AttributeValueMap_swigregister
AttributeValueMap_swigregister(AttributeValueMap)

class AttributeListMap(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, AttributeListMap, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, AttributeListMap, name)
    __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):
        this = _Sword.new_AttributeListMap(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

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

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

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

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

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

    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 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
    __del__ = lambda self: None
AttributeListMap_swigregister = _Sword.AttributeListMap_swigregister
AttributeListMap_swigregister(AttributeListMap)

class AttributeTypeListMap(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, AttributeTypeListMap, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, AttributeTypeListMap, name)
    __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):
        this = _Sword.new_AttributeTypeListMap(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

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

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

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

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

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

    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 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
    __del__ = lambda self: None
AttributeTypeListMap_swigregister = _Sword.AttributeTypeListMap_swigregister
AttributeTypeListMap_swigregister(AttributeTypeListMap)

class PyConfigEntMap(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, PyConfigEntMap, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, PyConfigEntMap, name)
    __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, key, x):
        return _Sword.PyConfigEntMap___setitem__(self, key, x)

    def __init__(self, *args):
        this = _Sword.new_PyConfigEntMap(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

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

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

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

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

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

    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 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
    __del__ = lambda self: None
PyConfigEntMap_swigregister = _Sword.PyConfigEntMap_swigregister
PyConfigEntMap_swigregister(PyConfigEntMap)

class PySectionMap(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, PySectionMap, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, PySectionMap, name)
    __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):
        this = _Sword.new_PySectionMap(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

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

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

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

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

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

    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 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
    __del__ = lambda self: None
PySectionMap_swigregister = _Sword.PySectionMap_swigregister
PySectionMap_swigregister(PySectionMap)

class ModuleMap(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ModuleMap, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ModuleMap, name)
    __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):
        this = _Sword.new_ModuleMap(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

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

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

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

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

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

    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 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
    __del__ = lambda self: None
ModuleMap_swigregister = _Sword.ModuleMap_swigregister
ModuleMap_swigregister(ModuleMap)

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

    def iterator(self):
        return _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 pop(self):
        return _Sword.StringVector_pop(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 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 clear(self):
        return _Sword.StringVector_clear(self)

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

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

    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 pop_back(self):
        return _Sword.StringVector_pop_back(self)

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

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

    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
    __del__ = lambda self: None
StringVector_swigregister = _Sword.StringVector_swigregister
StringVector_swigregister(StringVector)

class StringList(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, StringList, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, StringList, name)
    __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 pop(self):
        return _Sword.StringList_pop(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 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 clear(self):
        return _Sword.StringList_clear(self)

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

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

    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 pop_back(self):
        return _Sword.StringList_pop_back(self)

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

    def __init__(self, *args):
        this = _Sword.new_StringList(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    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
    __del__ = lambda self: None
StringList_swigregister = _Sword.StringList_swigregister
StringList_swigregister(StringList)

class InstallSourceMap(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, InstallSourceMap, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, InstallSourceMap, name)
    __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):
        this = _Sword.new_InstallSourceMap(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

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

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

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

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

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

    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 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
    __del__ = lambda self: None
InstallSourceMap_swigregister = _Sword.InstallSourceMap_swigregister
InstallSourceMap_swigregister(InstallSourceMap)

class DirEntryVector(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, DirEntryVector, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, DirEntryVector, name)
    __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 pop(self):
        return _Sword.DirEntryVector_pop(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 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 clear(self):
        return _Sword.DirEntryVector_clear(self)

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

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

    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 pop_back(self):
        return _Sword.DirEntryVector_pop_back(self)

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

    def __init__(self, *args):
        this = _Sword.new_DirEntryVector(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    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
    __del__ = lambda self: None
DirEntryVector_swigregister = _Sword.DirEntryVector_swigregister
DirEntryVector_swigregister(DirEntryVector)

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

    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
    __del__ = lambda self: None
SWClass_swigregister = _Sword.SWClass_swigregister
SWClass_swigregister(SWClass)

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

    def getClass(self):
        return _Sword.SWObject_getClass(self)

    def __init__(self):
        this = _Sword.new_SWObject()
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _Sword.delete_SWObject
    __del__ = lambda self: None
SWObject_swigregister = _Sword.SWObject_swigregister
SWObject_swigregister(SWObject)

class SWConfig(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, SWConfig, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, SWConfig, name)
    __repr__ = _swig_repr
    __swig_setmethods__["filename"] = _Sword.SWConfig_filename_set
    __swig_getmethods__["filename"] = _Sword.SWConfig_filename_get
    if _newclass:
        filename = _swig_property(_Sword.SWConfig_filename_get, _Sword.SWConfig_filename_set)

    def __init__(self, *args):
        this = _Sword.new_SWConfig(*args)
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _Sword.delete_SWConfig
    __del__ = lambda self: None

    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 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)

    def getSections(self):
        return _Sword.SWConfig_getSections(self)
SWConfig_swigregister = _Sword.SWConfig_swigregister
SWConfig_swigregister(SWConfig)


_Sword.SWORD_VERSION_NUM_swigconstant(_Sword)
SWORD_VERSION_NUM = _Sword.SWORD_VERSION_NUM

_Sword.SWORD_VERSION_STR_swigconstant(_Sword)
SWORD_VERSION_STR = _Sword.SWORD_VERSION_STR

_Sword.SWORD_VERSION_MAJOR_swigconstant(_Sword)
SWORD_VERSION_MAJOR = _Sword.SWORD_VERSION_MAJOR

_Sword.SWORD_VERSION_MINOR_swigconstant(_Sword)
SWORD_VERSION_MINOR = _Sword.SWORD_VERSION_MINOR

_Sword.SWORD_VERSION_MICRO_swigconstant(_Sword)
SWORD_VERSION_MICRO = _Sword.SWORD_VERSION_MICRO

_Sword.SWORD_VERSION_NANO_swigconstant(_Sword)
SWORD_VERSION_NANO = _Sword.SWORD_VERSION_NANO
class SWVersion(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, SWVersion, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, SWVersion, name)
    __repr__ = _swig_repr
    __swig_setmethods__["major"] = _Sword.SWVersion_major_set
    __swig_getmethods__["major"] = _Sword.SWVersion_major_get
    if _newclass:
        major = _swig_property(_Sword.SWVersion_major_get, _Sword.SWVersion_major_set)
    __swig_setmethods__["minor"] = _Sword.SWVersion_minor_set
    __swig_getmethods__["minor"] = _Sword.SWVersion_minor_get
    if _newclass:
        minor = _swig_property(_Sword.SWVersion_minor_get, _Sword.SWVersion_minor_set)
    __swig_setmethods__["minor2"] = _Sword.SWVersion_minor2_set
    __swig_getmethods__["minor2"] = _Sword.SWVersion_minor2_get
    if _newclass:
        minor2 = _swig_property(_Sword.SWVersion_minor2_get, _Sword.SWVersion_minor2_set)
    __swig_setmethods__["minor3"] = _Sword.SWVersion_minor3_set
    __swig_getmethods__["minor3"] = _Sword.SWVersion_minor3_get
    if _newclass:
        minor3 = _swig_property(_Sword.SWVersion_minor3_get, _Sword.SWVersion_minor3_set)

    def __init__(self, *args):
        this = _Sword.new_SWVersion(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    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)
    __swig_setmethods__["currentVersion"] = _Sword.SWVersion_currentVersion_set
    __swig_getmethods__["currentVersion"] = _Sword.SWVersion_currentVersion_get
    if _newclass:
        currentVersion = _swig_property(_Sword.SWVersion_currentVersion_get, _Sword.SWVersion_currentVersion_set)
    __swig_destroy__ = _Sword.delete_SWVersion
    __del__ = lambda self: None
SWVersion_swigregister = _Sword.SWVersion_swigregister
SWVersion_swigregister(SWVersion)

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

    def __init__(self, ipath, fileMode=-1):
        this = _Sword.new_RawVerse(ipath, fileMode)
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _Sword.delete_RawVerse
    __del__ = lambda self: None

    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)
    __swig_getmethods__["createModule"] = lambda x: _Sword.RawVerse_createModule
    if _newclass:
        createModule = staticmethod(_Sword.RawVerse_createModule)
RawVerse_swigregister = _Sword.RawVerse_swigregister
RawVerse_swigregister(RawVerse)
RawVerse.nl = _Sword.cvar.RawVerse_nl

def RawVerse_createModule(*args):
    return _Sword.RawVerse_createModule(*args)
RawVerse_createModule = _Sword.RawVerse_createModule

class zVerse(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, zVerse, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, zVerse, name)
    __repr__ = _swig_repr
    __swig_setmethods__["nl"] = _Sword.zVerse_nl_set
    __swig_getmethods__["nl"] = _Sword.zVerse_nl_get
    if _newclass:
        nl = _swig_property(_Sword.zVerse_nl_get, _Sword.zVerse_nl_set)

    def __init__(self, ipath, fileMode=-1, blockType=3, icomp=None):
        this = _Sword.new_zVerse(ipath, fileMode, blockType, icomp)
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _Sword.delete_zVerse
    __del__ = lambda self: None

    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)
    __swig_getmethods__["createModule"] = lambda x: _Sword.zVerse_createModule
    if _newclass:
        createModule = staticmethod(_Sword.zVerse_createModule)
zVerse_swigregister = _Sword.zVerse_swigregister
zVerse_swigregister(zVerse)

_Sword.VERSEBLOCKS_swigconstant(_Sword)
VERSEBLOCKS = _Sword.VERSEBLOCKS

_Sword.CHAPTERBLOCKS_swigconstant(_Sword)
CHAPTERBLOCKS = _Sword.CHAPTERBLOCKS

_Sword.BOOKBLOCKS_swigconstant(_Sword)
BOOKBLOCKS = _Sword.BOOKBLOCKS
zVerse.uniqueIndexID = _Sword.cvar.zVerse_uniqueIndexID

def zVerse_createModule(*args):
    return _Sword.zVerse_createModule(*args)
zVerse_createModule = _Sword.zVerse_createModule

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

    def __init__(self, ipath, fileMode=-1, caseSensitive=False):
        this = _Sword.new_RawStr(ipath, fileMode, caseSensitive)
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _Sword.delete_RawStr
    __del__ = lambda self: None

    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)
    __swig_getmethods__["createModule"] = lambda x: _Sword.RawStr_createModule
    if _newclass:
        createModule = staticmethod(_Sword.RawStr_createModule)
RawStr_swigregister = _Sword.RawStr_swigregister
RawStr_swigregister(RawStr)
RawStr.nl = _Sword.cvar.RawStr_nl

def RawStr_createModule(path):
    return _Sword.RawStr_createModule(path)
RawStr_createModule = _Sword.RawStr_createModule

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

    def __init__(self, ipath, fileMode=-1, caseSensitive=False):
        this = _Sword.new_RawStr4(ipath, fileMode, caseSensitive)
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _Sword.delete_RawStr4
    __del__ = lambda self: None

    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)
    __swig_getmethods__["createModule"] = lambda x: _Sword.RawStr4_createModule
    if _newclass:
        createModule = staticmethod(_Sword.RawStr4_createModule)
RawStr4_swigregister = _Sword.RawStr4_swigregister
RawStr4_swigregister(RawStr4)
RawStr4.nl = _Sword.cvar.RawStr4_nl

def RawStr4_createModule(path):
    return _Sword.RawStr4_createModule(path)
RawStr4_createModule = _Sword.RawStr4_createModule

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

    def __init__(self, ipath, fileMode=-1, blockCount=100, icomp=None, caseSensitive=False):
        this = _Sword.new_zStr(ipath, fileMode, blockCount, icomp, caseSensitive)
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _Sword.delete_zStr
    __del__ = lambda self: None

    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)
    __swig_getmethods__["createModule"] = lambda x: _Sword.zStr_createModule
    if _newclass:
        createModule = staticmethod(_Sword.zStr_createModule)
zStr_swigregister = _Sword.zStr_swigregister
zStr_swigregister(zStr)

def zStr_createModule(path):
    return _Sword.zStr_createModule(path)
zStr_createModule = _Sword.zStr_createModule


_Sword.KEYERR_OUTOFBOUNDS_swigconstant(_Sword)
KEYERR_OUTOFBOUNDS = _Sword.KEYERR_OUTOFBOUNDS
class SW_POSITION(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, SW_POSITION, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, SW_POSITION, name)
    __repr__ = _swig_repr

    def __init__(self, ipos):
        this = _Sword.new_SW_POSITION(ipos)
        try:
            self.this.append(this)
        except:
            self.this = this

    def getPosition(self):
        return _Sword.SW_POSITION_getPosition(self)
    __swig_destroy__ = _Sword.delete_SW_POSITION
    __del__ = lambda self: None
SW_POSITION_swigregister = _Sword.SW_POSITION_swigregister
SW_POSITION_swigregister(SW_POSITION)

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

    def __init__(self, *args):
        this = _Sword.new_SWKey(*args)
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _Sword.delete_SWKey
    __del__ = lambda self: None

    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 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 getOSISRefRangeText(self):
        return _Sword.SWKey_getOSISRefRangeText(self)

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

    def clearBound(self):
        return _Sword.SWKey_clearBound(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)
SWKey_swigregister = _Sword.SWKey_swigregister
SWKey_swigregister(SWKey)

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

    def __init__(self, *args):
        this = _Sword.new_ListKey(*args)
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _Sword.delete_ListKey
    __del__ = lambda self: None

    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 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 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)
    __swig_getmethods__["castTo"] = lambda x: _Sword.ListKey_castTo
    if _newclass:
        castTo = staticmethod(_Sword.ListKey_castTo)
ListKey_swigregister = _Sword.ListKey_swigregister
ListKey_swigregister(ListKey)

def ListKey_castTo(o):
    return _Sword.ListKey_castTo(o)
ListKey_castTo = _Sword.ListKey_castTo

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

    def __init__(self, *args):
        this = _Sword.new_VerseKey(*args)
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _Sword.delete_VerseKey
    __del__ = lambda self: None

    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)
    __swig_getmethods__["convertToOSIS"] = lambda x: _Sword.VerseKey_convertToOSIS
    if _newclass:
        convertToOSIS = staticmethod(_Sword.VerseKey_convertToOSIS)

    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 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)
    __swig_getmethods__["castTo"] = lambda x: _Sword.VerseKey_castTo
    if _newclass:
        castTo = staticmethod(_Sword.VerseKey_castTo)

    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)
VerseKey_swigregister = _Sword.VerseKey_swigregister
VerseKey_swigregister(VerseKey)

def VerseKey_convertToOSIS(inRef, defaultKey):
    return _Sword.VerseKey_convertToOSIS(inRef, defaultKey)
VerseKey_convertToOSIS = _Sword.VerseKey_convertToOSIS

def VerseKey_castTo(o):
    return _Sword.VerseKey_castTo(o)
VerseKey_castTo = _Sword.VerseKey_castTo

class abbrev(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, abbrev, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, abbrev, name)
    __repr__ = _swig_repr
    __swig_getmethods__["ab"] = _Sword.abbrev_ab_get
    if _newclass:
        ab = _swig_property(_Sword.abbrev_ab_get)
    __swig_setmethods__["osis"] = _Sword.abbrev_osis_set
    __swig_getmethods__["osis"] = _Sword.abbrev_osis_get
    if _newclass:
        osis = _swig_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):
        this = _Sword.new_abbrev()
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _Sword.delete_abbrev
    __del__ = lambda self: None
abbrev_swigregister = _Sword.abbrev_swigregister
abbrev_swigregister(abbrev)

class sbook(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, sbook, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, sbook, name)
    __repr__ = _swig_repr
    __swig_getmethods__["name"] = _Sword.sbook_name_get
    if _newclass:
        name = _swig_property(_Sword.sbook_name_get)
    __swig_setmethods__["osis"] = _Sword.sbook_osis_set
    __swig_getmethods__["osis"] = _Sword.sbook_osis_get
    if _newclass:
        osis = _swig_property(_Sword.sbook_osis_get, _Sword.sbook_osis_set)
    __swig_getmethods__["prefAbbrev"] = _Sword.sbook_prefAbbrev_get
    if _newclass:
        prefAbbrev = _swig_property(_Sword.sbook_prefAbbrev_get)
    __swig_setmethods__["chapmax"] = _Sword.sbook_chapmax_set
    __swig_getmethods__["chapmax"] = _Sword.sbook_chapmax_get
    if _newclass:
        chapmax = _swig_property(_Sword.sbook_chapmax_get, _Sword.sbook_chapmax_set)

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

    def __init__(self):
        this = _Sword.new_sbook()
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _Sword.delete_sbook
    __del__ = lambda self: None
sbook_swigregister = _Sword.sbook_swigregister
sbook_swigregister(sbook)

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

    def __init__(self):
        this = _Sword.new_VersificationMgr()
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _Sword.delete_VersificationMgr
    __del__ = lambda self: None
    __swig_getmethods__["getSystemVersificationMgr"] = lambda x: _Sword.VersificationMgr_getSystemVersificationMgr
    if _newclass:
        getSystemVersificationMgr = staticmethod(_Sword.VersificationMgr_getSystemVersificationMgr)
    __swig_getmethods__["setSystemVersificationMgr"] = lambda x: _Sword.VersificationMgr_setSystemVersificationMgr
    if _newclass:
        setSystemVersificationMgr = staticmethod(_Sword.VersificationMgr_setSystemVersificationMgr)

    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)
VersificationMgr_swigregister = _Sword.VersificationMgr_swigregister
VersificationMgr_swigregister(VersificationMgr)

def VersificationMgr_getSystemVersificationMgr():
    return _Sword.VersificationMgr_getSystemVersificationMgr()
VersificationMgr_getSystemVersificationMgr = _Sword.VersificationMgr_getSystemVersificationMgr

def VersificationMgr_setSystemVersificationMgr(newVersificationMgr):
    return _Sword.VersificationMgr_setSystemVersificationMgr(newVersificationMgr)
VersificationMgr_setSystemVersificationMgr = _Sword.VersificationMgr_setSystemVersificationMgr

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

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr
    __swig_setmethods__["posChangeListener"] = _Sword.TreeKey_posChangeListener_set
    __swig_getmethods__["posChangeListener"] = _Sword.TreeKey_posChangeListener_get
    if _newclass:
        posChangeListener = _swig_property(_Sword.TreeKey_posChangeListener_get, _Sword.TreeKey_posChangeListener_set)

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

    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)
    __swig_getmethods__["castTo"] = lambda x: _Sword.TreeKey_castTo
    if _newclass:
        castTo = staticmethod(_Sword.TreeKey_castTo)
TreeKey_swigregister = _Sword.TreeKey_swigregister
TreeKey_swigregister(TreeKey)
builtin_abbrevs = cvar.builtin_abbrevs

def TreeKey_castTo(o):
    return _Sword.TreeKey_castTo(o)
TreeKey_castTo = _Sword.TreeKey_castTo

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

    def __init__(self, *args):
        this = _Sword.new_TreeKeyIdx(*args)
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _Sword.delete_TreeKeyIdx
    __del__ = lambda self: None

    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)
    __swig_getmethods__["create"] = lambda x: _Sword.TreeKeyIdx_create
    if _newclass:
        create = staticmethod(_Sword.TreeKeyIdx_create)
    __swig_getmethods__["castTo"] = lambda x: _Sword.TreeKeyIdx_castTo
    if _newclass:
        castTo = staticmethod(_Sword.TreeKeyIdx_castTo)
TreeKeyIdx_swigregister = _Sword.TreeKeyIdx_swigregister
TreeKeyIdx_swigregister(TreeKeyIdx)

def TreeKeyIdx_create(path):
    return _Sword.TreeKeyIdx_create(path)
TreeKeyIdx_create = _Sword.TreeKeyIdx_create

def TreeKeyIdx_castTo(o):
    return _Sword.TreeKeyIdx_castTo(o)
TreeKeyIdx_castTo = _Sword.TreeKeyIdx_castTo

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

    def __init__(self, *args):
        this = _Sword.new_VerseTreeKey(*args)
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _Sword.delete_VerseTreeKey
    __del__ = lambda self: None

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

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

    def getTreeKey(self):
        return _Sword.VerseTreeKey_getTreeKey(self)

    def positionChanged(self):
        return _Sword.VerseTreeKey_positionChanged(self)
    __swig_setmethods__["internalPosChange"] = _Sword.VerseTreeKey_internalPosChange_set
    __swig_getmethods__["internalPosChange"] = _Sword.VerseTreeKey_internalPosChange_get
    if _newclass:
        internalPosChange = _swig_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)
    __swig_getmethods__["castTo"] = lambda x: _Sword.VerseTreeKey_castTo
    if _newclass:
        castTo = staticmethod(_Sword.VerseTreeKey_castTo)
VerseTreeKey_swigregister = _Sword.VerseTreeKey_swigregister
VerseTreeKey_swigregister(VerseTreeKey)

def VerseTreeKey_castTo(o):
    return _Sword.VerseTreeKey_castTo(o)
VerseTreeKey_castTo = _Sword.VerseTreeKey_castTo

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

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

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

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

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

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

    def getHeader(self):
        return _Sword.SWFilter_getHeader(self)
SWFilter_swigregister = _Sword.SWFilter_swigregister
SWFilter_swigregister(SWFilter)

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

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

    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)
    __swig_getmethods__["castTo"] = lambda x: _Sword.SWOptionFilter_castTo
    if _newclass:
        castTo = staticmethod(_Sword.SWOptionFilter_castTo)
SWOptionFilter_swigregister = _Sword.SWOptionFilter_swigregister
SWOptionFilter_swigregister(SWOptionFilter)

def SWOptionFilter_castTo(o):
    return _Sword.SWOptionFilter_castTo(o)
SWOptionFilter_castTo = _Sword.SWOptionFilter_castTo

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

    def __init__(self):
        this = _Sword.new_SWFilterMgr()
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _Sword.delete_SWFilterMgr
    __del__ = lambda self: None

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

    def getParentMgr(self):
        return _Sword.SWFilterMgr_getParentMgr(self)
SWFilterMgr_swigregister = _Sword.SWFilterMgr_swigregister
SWFilterMgr_swigregister(SWFilterMgr)

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

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    __swig_getmethods__["setSystemStringMgr"] = lambda x: _Sword.StringMgr_setSystemStringMgr
    if _newclass:
        setSystemStringMgr = staticmethod(_Sword.StringMgr_setSystemStringMgr)
    __swig_getmethods__["getSystemStringMgr"] = lambda x: _Sword.StringMgr_getSystemStringMgr
    if _newclass:
        getSystemStringMgr = staticmethod(_Sword.StringMgr_getSystemStringMgr)
    __swig_getmethods__["hasUTF8Support"] = lambda x: _Sword.StringMgr_hasUTF8Support
    if _newclass:
        hasUTF8Support = staticmethod(_Sword.StringMgr_hasUTF8Support)

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

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

def StringMgr_setSystemStringMgr(newStringMgr):
    return _Sword.StringMgr_setSystemStringMgr(newStringMgr)
StringMgr_setSystemStringMgr = _Sword.StringMgr_setSystemStringMgr

def StringMgr_getSystemStringMgr():
    return _Sword.StringMgr_getSystemStringMgr()
StringMgr_getSystemStringMgr = _Sword.StringMgr_getSystemStringMgr

def StringMgr_hasUTF8Support():
    return _Sword.StringMgr_hasUTF8Support()
StringMgr_hasUTF8Support = _Sword.StringMgr_hasUTF8Support


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

def toupperstr(*args):
    return _Sword.toupperstr(*args)
toupperstr = _Sword.toupperstr
class PyStringMgr(StringMgr):
    __swig_setmethods__ = {}
    for _s in [StringMgr]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, PyStringMgr, name, value)
    __swig_getmethods__ = {}
    for _s in [StringMgr]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, PyStringMgr, name)
    __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
        this = _Sword.new_PyStringMgr(_self, )
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _Sword.delete_PyStringMgr
    __del__ = lambda self: None
    def __disown__(self):
        self.this.disown()
        _Sword.disown_PyStringMgr(self)
        return weakref_proxy(self)

    def supportsUnicode(self):
        return _Sword.PyStringMgr_supportsUnicode(self)
PyStringMgr_swigregister = _Sword.PyStringMgr_swigregister
PyStringMgr_swigregister(PyStringMgr)

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

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

    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)
SWSearchable_swigregister = _Sword.SWSearchable_swigregister
SWSearchable_swigregister(SWSearchable)


_Sword.SEARCHFLAG_MATCHWHOLEENTRY_swigconstant(_Sword)
SEARCHFLAG_MATCHWHOLEENTRY = _Sword.SEARCHFLAG_MATCHWHOLEENTRY
class SWModule(SWSearchable):
    __swig_setmethods__ = {}
    for _s in [SWSearchable]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, SWModule, name, value)
    __swig_getmethods__ = {}
    for _s in [SWSearchable]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, SWModule, name)

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr
    __swig_setmethods__["terminateSearch"] = _Sword.SWModule_terminateSearch_set
    __swig_getmethods__["terminateSearch"] = _Sword.SWModule_terminateSearch_get
    if _newclass:
        terminateSearch = _swig_property(_Sword.SWModule_terminateSearch_get, _Sword.SWModule_terminateSearch_set)
    __swig_destroy__ = _Sword.delete_SWModule
    __del__ = lambda self: None

    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 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)
    __swig_getmethods__["createModule"] = lambda x: _Sword.SWModule_createModule
    if _newclass:
        createModule = staticmethod(_Sword.SWModule_createModule)

    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 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)
    __swig_getmethods__["castTo"] = lambda x: _Sword.SWModule_castTo
    if _newclass:
        castTo = staticmethod(_Sword.SWModule_castTo)

    def getEntryAttributesMap(self):
        return _Sword.SWModule_getEntryAttributesMap(self)

    def getConfigMap(self):
        return _Sword.SWModule_getConfigMap(self)
SWModule_swigregister = _Sword.SWModule_swigregister
SWModule_swigregister(SWModule)

def SWModule_createModule(path):
    return _Sword.SWModule_createModule(path)
SWModule_createModule = _Sword.SWModule_createModule

def SWModule_castTo(o):
    return _Sword.SWModule_castTo(o)
SWModule_castTo = _Sword.SWModule_castTo

class SWMgr(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, SWMgr, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, SWMgr, name)
    __repr__ = _swig_repr
    __swig_setmethods__["MODTYPE_BIBLES"] = _Sword.SWMgr_MODTYPE_BIBLES_set
    __swig_getmethods__["MODTYPE_BIBLES"] = _Sword.SWMgr_MODTYPE_BIBLES_get
    if _newclass:
        MODTYPE_BIBLES = _swig_property(_Sword.SWMgr_MODTYPE_BIBLES_get, _Sword.SWMgr_MODTYPE_BIBLES_set)
    __swig_setmethods__["MODTYPE_COMMENTARIES"] = _Sword.SWMgr_MODTYPE_COMMENTARIES_set
    __swig_getmethods__["MODTYPE_COMMENTARIES"] = _Sword.SWMgr_MODTYPE_COMMENTARIES_get
    if _newclass:
        MODTYPE_COMMENTARIES = _swig_property(_Sword.SWMgr_MODTYPE_COMMENTARIES_get, _Sword.SWMgr_MODTYPE_COMMENTARIES_set)
    __swig_setmethods__["MODTYPE_LEXDICTS"] = _Sword.SWMgr_MODTYPE_LEXDICTS_set
    __swig_getmethods__["MODTYPE_LEXDICTS"] = _Sword.SWMgr_MODTYPE_LEXDICTS_get
    if _newclass:
        MODTYPE_LEXDICTS = _swig_property(_Sword.SWMgr_MODTYPE_LEXDICTS_get, _Sword.SWMgr_MODTYPE_LEXDICTS_set)
    __swig_setmethods__["MODTYPE_GENBOOKS"] = _Sword.SWMgr_MODTYPE_GENBOOKS_set
    __swig_getmethods__["MODTYPE_GENBOOKS"] = _Sword.SWMgr_MODTYPE_GENBOOKS_get
    if _newclass:
        MODTYPE_GENBOOKS = _swig_property(_Sword.SWMgr_MODTYPE_GENBOOKS_get, _Sword.SWMgr_MODTYPE_GENBOOKS_set)
    __swig_setmethods__["MODTYPE_DAILYDEVOS"] = _Sword.SWMgr_MODTYPE_DAILYDEVOS_set
    __swig_getmethods__["MODTYPE_DAILYDEVOS"] = _Sword.SWMgr_MODTYPE_DAILYDEVOS_get
    if _newclass:
        MODTYPE_DAILYDEVOS = _swig_property(_Sword.SWMgr_MODTYPE_DAILYDEVOS_get, _Sword.SWMgr_MODTYPE_DAILYDEVOS_set)
    __swig_setmethods__["isICU"] = _Sword.SWMgr_isICU_set
    __swig_getmethods__["isICU"] = _Sword.SWMgr_isICU_get
    if _newclass:
        isICU = _swig_property(_Sword.SWMgr_isICU_get, _Sword.SWMgr_isICU_set)
    __swig_setmethods__["globalConfPath"] = _Sword.SWMgr_globalConfPath_set
    __swig_getmethods__["globalConfPath"] = _Sword.SWMgr_globalConfPath_get
    if _newclass:
        globalConfPath = _swig_property(_Sword.SWMgr_globalConfPath_get, _Sword.SWMgr_globalConfPath_set)
    __swig_getmethods__["getHomeDir"] = lambda x: _Sword.SWMgr_getHomeDir
    if _newclass:
        getHomeDir = staticmethod(_Sword.SWMgr_getHomeDir)
    __swig_setmethods__["config"] = _Sword.SWMgr_config_set
    __swig_getmethods__["config"] = _Sword.SWMgr_config_get
    if _newclass:
        config = _swig_property(_Sword.SWMgr_config_get, _Sword.SWMgr_config_set)
    __swig_setmethods__["sysConfig"] = _Sword.SWMgr_sysConfig_set
    __swig_getmethods__["sysConfig"] = _Sword.SWMgr_sysConfig_get
    if _newclass:
        sysConfig = _swig_property(_Sword.SWMgr_sysConfig_get, _Sword.SWMgr_sysConfig_set)
    __swig_setmethods__["prefixPath"] = _Sword.SWMgr_prefixPath_set
    __swig_getmethods__["prefixPath"] = _Sword.SWMgr_prefixPath_get
    if _newclass:
        prefixPath = _swig_property(_Sword.SWMgr_prefixPath_get, _Sword.SWMgr_prefixPath_set)
    __swig_setmethods__["configPath"] = _Sword.SWMgr_configPath_set
    __swig_getmethods__["configPath"] = _Sword.SWMgr_configPath_get
    if _newclass:
        configPath = _swig_property(_Sword.SWMgr_configPath_get, _Sword.SWMgr_configPath_set)

    def getModule(self, *args):
        return _Sword.SWMgr_getModule(self, *args)

    def __init__(self, *args):
        this = _Sword.new_SWMgr(*args)
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _Sword.delete_SWMgr
    __del__ = lambda self: None

    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 getModules(self):
        return _Sword.SWMgr_getModules(self)

    def getModuleAt(self, pos):
        return _Sword.SWMgr_getModuleAt(self, pos)
SWMgr_swigregister = _Sword.SWMgr_swigregister
SWMgr_swigregister(SWMgr)

def SWMgr_getHomeDir():
    return _Sword.SWMgr_getHomeDir()
SWMgr_getHomeDir = _Sword.SWMgr_getHomeDir

class DirEntry(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, DirEntry, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, DirEntry, name)
    __repr__ = _swig_repr
    __swig_setmethods__["name"] = _Sword.DirEntry_name_set
    __swig_getmethods__["name"] = _Sword.DirEntry_name_get
    if _newclass:
        name = _swig_property(_Sword.DirEntry_name_get, _Sword.DirEntry_name_set)
    __swig_setmethods__["size"] = _Sword.DirEntry_size_set
    __swig_getmethods__["size"] = _Sword.DirEntry_size_get
    if _newclass:
        size = _swig_property(_Sword.DirEntry_size_get, _Sword.DirEntry_size_set)
    __swig_setmethods__["isDirectory"] = _Sword.DirEntry_isDirectory_set
    __swig_getmethods__["isDirectory"] = _Sword.DirEntry_isDirectory_get
    if _newclass:
        isDirectory = _swig_property(_Sword.DirEntry_isDirectory_get, _Sword.DirEntry_isDirectory_set)

    def __init__(self):
        this = _Sword.new_DirEntry()
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _Sword.delete_DirEntry
    __del__ = lambda self: None
DirEntry_swigregister = _Sword.DirEntry_swigregister
DirEntry_swigregister(DirEntry)

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

    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)
    __swig_setmethods__["path"] = _Sword.FileDesc_path_set
    __swig_getmethods__["path"] = _Sword.FileDesc_path_get
    if _newclass:
        path = _swig_property(_Sword.FileDesc_path_get, _Sword.FileDesc_path_set)
    __swig_setmethods__["mode"] = _Sword.FileDesc_mode_set
    __swig_getmethods__["mode"] = _Sword.FileDesc_mode_get
    if _newclass:
        mode = _swig_property(_Sword.FileDesc_mode_get, _Sword.FileDesc_mode_set)
    __swig_setmethods__["perms"] = _Sword.FileDesc_perms_set
    __swig_getmethods__["perms"] = _Sword.FileDesc_perms_get
    if _newclass:
        perms = _swig_property(_Sword.FileDesc_perms_get, _Sword.FileDesc_perms_set)
    __swig_setmethods__["tryDowngrade"] = _Sword.FileDesc_tryDowngrade_set
    __swig_getmethods__["tryDowngrade"] = _Sword.FileDesc_tryDowngrade_get
    if _newclass:
        tryDowngrade = _swig_property(_Sword.FileDesc_tryDowngrade_get, _Sword.FileDesc_tryDowngrade_set)
FileDesc_swigregister = _Sword.FileDesc_swigregister
FileDesc_swigregister(FileDesc)

class FileMgr(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, FileMgr, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, FileMgr, name)
    __repr__ = _swig_repr
    __swig_setmethods__["CREAT"] = _Sword.FileMgr_CREAT_set
    __swig_getmethods__["CREAT"] = _Sword.FileMgr_CREAT_get
    if _newclass:
        CREAT = _swig_property(_Sword.FileMgr_CREAT_get, _Sword.FileMgr_CREAT_set)
    __swig_setmethods__["APPEND"] = _Sword.FileMgr_APPEND_set
    __swig_getmethods__["APPEND"] = _Sword.FileMgr_APPEND_get
    if _newclass:
        APPEND = _swig_property(_Sword.FileMgr_APPEND_get, _Sword.FileMgr_APPEND_set)
    __swig_setmethods__["TRUNC"] = _Sword.FileMgr_TRUNC_set
    __swig_getmethods__["TRUNC"] = _Sword.FileMgr_TRUNC_get
    if _newclass:
        TRUNC = _swig_property(_Sword.FileMgr_TRUNC_get, _Sword.FileMgr_TRUNC_set)
    __swig_setmethods__["RDONLY"] = _Sword.FileMgr_RDONLY_set
    __swig_getmethods__["RDONLY"] = _Sword.FileMgr_RDONLY_get
    if _newclass:
        RDONLY = _swig_property(_Sword.FileMgr_RDONLY_get, _Sword.FileMgr_RDONLY_set)
    __swig_setmethods__["RDWR"] = _Sword.FileMgr_RDWR_set
    __swig_getmethods__["RDWR"] = _Sword.FileMgr_RDWR_get
    if _newclass:
        RDWR = _swig_property(_Sword.FileMgr_RDWR_get, _Sword.FileMgr_RDWR_set)
    __swig_setmethods__["WRONLY"] = _Sword.FileMgr_WRONLY_set
    __swig_getmethods__["WRONLY"] = _Sword.FileMgr_WRONLY_get
    if _newclass:
        WRONLY = _swig_property(_Sword.FileMgr_WRONLY_get, _Sword.FileMgr_WRONLY_set)
    __swig_setmethods__["IREAD"] = _Sword.FileMgr_IREAD_set
    __swig_getmethods__["IREAD"] = _Sword.FileMgr_IREAD_get
    if _newclass:
        IREAD = _swig_property(_Sword.FileMgr_IREAD_get, _Sword.FileMgr_IREAD_set)
    __swig_setmethods__["IWRITE"] = _Sword.FileMgr_IWRITE_set
    __swig_getmethods__["IWRITE"] = _Sword.FileMgr_IWRITE_get
    if _newclass:
        IWRITE = _swig_property(_Sword.FileMgr_IWRITE_get, _Sword.FileMgr_IWRITE_set)
    __swig_setmethods__["maxFiles"] = _Sword.FileMgr_maxFiles_set
    __swig_getmethods__["maxFiles"] = _Sword.FileMgr_maxFiles_get
    if _newclass:
        maxFiles = _swig_property(_Sword.FileMgr_maxFiles_get, _Sword.FileMgr_maxFiles_set)
    __swig_getmethods__["getSystemFileMgr"] = lambda x: _Sword.FileMgr_getSystemFileMgr
    if _newclass:
        getSystemFileMgr = staticmethod(_Sword.FileMgr_getSystemFileMgr)
    __swig_getmethods__["setSystemFileMgr"] = lambda x: _Sword.FileMgr_setSystemFileMgr
    if _newclass:
        setSystemFileMgr = staticmethod(_Sword.FileMgr_setSystemFileMgr)

    def __init__(self, maxFiles=35):
        this = _Sword.new_FileMgr(maxFiles)
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _Sword.delete_FileMgr
    __del__ = lambda self: None

    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)
    __swig_getmethods__["existsFile"] = lambda x: _Sword.FileMgr_existsFile
    if _newclass:
        existsFile = staticmethod(_Sword.FileMgr_existsFile)
    __swig_getmethods__["existsDir"] = lambda x: _Sword.FileMgr_existsDir
    if _newclass:
        existsDir = staticmethod(_Sword.FileMgr_existsDir)

    def trunc(self, file):
        return _Sword.FileMgr_trunc(self, file)
    __swig_getmethods__["isDirectory"] = lambda x: _Sword.FileMgr_isDirectory
    if _newclass:
        isDirectory = staticmethod(_Sword.FileMgr_isDirectory)
    __swig_getmethods__["createParent"] = lambda x: _Sword.FileMgr_createParent
    if _newclass:
        createParent = staticmethod(_Sword.FileMgr_createParent)
    __swig_getmethods__["createPathAndFile"] = lambda x: _Sword.FileMgr_createPathAndFile
    if _newclass:
        createPathAndFile = staticmethod(_Sword.FileMgr_createPathAndFile)
    __swig_getmethods__["openFileReadOnly"] = lambda x: _Sword.FileMgr_openFileReadOnly
    if _newclass:
        openFileReadOnly = staticmethod(_Sword.FileMgr_openFileReadOnly)
    __swig_getmethods__["copyFile"] = lambda x: _Sword.FileMgr_copyFile
    if _newclass:
        copyFile = staticmethod(_Sword.FileMgr_copyFile)
    __swig_getmethods__["copyDir"] = lambda x: _Sword.FileMgr_copyDir
    if _newclass:
        copyDir = staticmethod(_Sword.FileMgr_copyDir)
    __swig_getmethods__["removeDir"] = lambda x: _Sword.FileMgr_removeDir
    if _newclass:
        removeDir = staticmethod(_Sword.FileMgr_removeDir)
    __swig_getmethods__["removeFile"] = lambda x: _Sword.FileMgr_removeFile
    if _newclass:
        removeFile = staticmethod(_Sword.FileMgr_removeFile)
    __swig_getmethods__["getLine"] = lambda x: _Sword.FileMgr_getLine
    if _newclass:
        getLine = staticmethod(_Sword.FileMgr_getLine)
FileMgr_swigregister = _Sword.FileMgr_swigregister
FileMgr_swigregister(FileMgr)

def FileMgr_getSystemFileMgr():
    return _Sword.FileMgr_getSystemFileMgr()
FileMgr_getSystemFileMgr = _Sword.FileMgr_getSystemFileMgr

def FileMgr_setSystemFileMgr(newFileMgr):
    return _Sword.FileMgr_setSystemFileMgr(newFileMgr)
FileMgr_setSystemFileMgr = _Sword.FileMgr_setSystemFileMgr

def FileMgr_existsFile(ipath, ifileName=None):
    return _Sword.FileMgr_existsFile(ipath, ifileName)
FileMgr_existsFile = _Sword.FileMgr_existsFile

def FileMgr_existsDir(ipath, idirName=None):
    return _Sword.FileMgr_existsDir(ipath, idirName)
FileMgr_existsDir = _Sword.FileMgr_existsDir

def FileMgr_isDirectory(path):
    return _Sword.FileMgr_isDirectory(path)
FileMgr_isDirectory = _Sword.FileMgr_isDirectory

def FileMgr_createParent(pName):
    return _Sword.FileMgr_createParent(pName)
FileMgr_createParent = _Sword.FileMgr_createParent

def FileMgr_createPathAndFile(fName):
    return _Sword.FileMgr_createPathAndFile(fName)
FileMgr_createPathAndFile = _Sword.FileMgr_createPathAndFile

def FileMgr_openFileReadOnly(fName):
    return _Sword.FileMgr_openFileReadOnly(fName)
FileMgr_openFileReadOnly = _Sword.FileMgr_openFileReadOnly

def FileMgr_copyFile(srcFile, destFile):
    return _Sword.FileMgr_copyFile(srcFile, destFile)
FileMgr_copyFile = _Sword.FileMgr_copyFile

def FileMgr_copyDir(srcDir, destDir):
    return _Sword.FileMgr_copyDir(srcDir, destDir)
FileMgr_copyDir = _Sword.FileMgr_copyDir

def FileMgr_removeDir(targetDir):
    return _Sword.FileMgr_removeDir(targetDir)
FileMgr_removeDir = _Sword.FileMgr_removeDir

def FileMgr_removeFile(fName):
    return _Sword.FileMgr_removeFile(fName)
FileMgr_removeFile = _Sword.FileMgr_removeFile

def FileMgr_getLine(fDesc, line):
    return _Sword.FileMgr_getLine(fDesc, line)
FileMgr_getLine = _Sword.FileMgr_getLine

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

    def __init__(self, *args):
        this = _Sword.new_EncodingFilterMgr(*args)
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _Sword.delete_EncodingFilterMgr
    __del__ = lambda self: None

    def Encoding(self, enc):
        return _Sword.EncodingFilterMgr_Encoding(self, enc)
    __swig_getmethods__["castTo"] = lambda x: _Sword.EncodingFilterMgr_castTo
    if _newclass:
        castTo = staticmethod(_Sword.EncodingFilterMgr_castTo)
EncodingFilterMgr_swigregister = _Sword.EncodingFilterMgr_swigregister
EncodingFilterMgr_swigregister(EncodingFilterMgr)

def EncodingFilterMgr_castTo(o):
    return _Sword.EncodingFilterMgr_castTo(o)
EncodingFilterMgr_castTo = _Sword.EncodingFilterMgr_castTo

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

    def __init__(self, *args):
        this = _Sword.new_MarkupFilterMgr(*args)
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _Sword.delete_MarkupFilterMgr
    __del__ = lambda self: None

    def Markup(self, *args):
        return _Sword.MarkupFilterMgr_Markup(self, *args)
    __swig_getmethods__["castTo"] = lambda x: _Sword.MarkupFilterMgr_castTo
    if _newclass:
        castTo = staticmethod(_Sword.MarkupFilterMgr_castTo)
MarkupFilterMgr_swigregister = _Sword.MarkupFilterMgr_swigregister
MarkupFilterMgr_swigregister(MarkupFilterMgr)

def MarkupFilterMgr_castTo(o):
    return _Sword.MarkupFilterMgr_castTo(o)
MarkupFilterMgr_castTo = _Sword.MarkupFilterMgr_castTo

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

    def __init__(self, ifilename):
        this = _Sword.new_SWLocale(ifilename)
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _Sword.delete_SWLocale
    __del__ = lambda self: None

    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)
    __swig_setmethods__["DEFAULT_LOCALE_NAME"] = _Sword.SWLocale_DEFAULT_LOCALE_NAME_set
    __swig_getmethods__["DEFAULT_LOCALE_NAME"] = _Sword.SWLocale_DEFAULT_LOCALE_NAME_get
    if _newclass:
        DEFAULT_LOCALE_NAME = _swig_property(_Sword.SWLocale_DEFAULT_LOCALE_NAME_get, _Sword.SWLocale_DEFAULT_LOCALE_NAME_set)

    def getBookAbbrevs(self):
        return _Sword.SWLocale_getBookAbbrevs(self)
SWLocale_swigregister = _Sword.SWLocale_swigregister
SWLocale_swigregister(SWLocale)
ENDOFABBREVS = cvar.ENDOFABBREVS

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

    def __init__(self):
        this = _Sword.new_SWCompress()
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _Sword.delete_SWCompress
    __del__ = lambda self: None

    def Encode(self):
        return _Sword.SWCompress_Encode(self)

    def Decode(self):
        return _Sword.SWCompress_Decode(self)
SWCompress_swigregister = _Sword.SWCompress_swigregister
SWCompress_swigregister(SWCompress)

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

    def __init__(self):
        this = _Sword.new_LZSSCompress()
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _Sword.delete_LZSSCompress
    __del__ = lambda self: None

    def Encode(self):
        return _Sword.LZSSCompress_Encode(self)

    def Decode(self):
        return _Sword.LZSSCompress_Decode(self)
    __swig_getmethods__["castTo"] = lambda x: _Sword.LZSSCompress_castTo
    if _newclass:
        castTo = staticmethod(_Sword.LZSSCompress_castTo)
LZSSCompress_swigregister = _Sword.LZSSCompress_swigregister
LZSSCompress_swigregister(LZSSCompress)

def LZSSCompress_castTo(o):
    return _Sword.LZSSCompress_castTo(o)
LZSSCompress_castTo = _Sword.LZSSCompress_castTo

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

    def __init__(self):
        this = _Sword.new_ZipCompress()
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _Sword.delete_ZipCompress
    __del__ = lambda self: None

    def Encode(self):
        return _Sword.ZipCompress_Encode(self)

    def Decode(self):
        return _Sword.ZipCompress_Decode(self)
    __swig_getmethods__["castTo"] = lambda x: _Sword.ZipCompress_castTo
    if _newclass:
        castTo = staticmethod(_Sword.ZipCompress_castTo)
ZipCompress_swigregister = _Sword.ZipCompress_swigregister
ZipCompress_swigregister(ZipCompress)

def ZipCompress_castTo(o):
    return _Sword.ZipCompress_castTo(o)
ZipCompress_castTo = _Sword.ZipCompress_castTo

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

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

    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)
    __swig_getmethods__["castTo"] = lambda x: _Sword.SWCom_castTo
    if _newclass:
        castTo = staticmethod(_Sword.SWCom_castTo)
SWCom_swigregister = _Sword.SWCom_swigregister
SWCom_swigregister(SWCom)

def SWCom_castTo(o):
    return _Sword.SWCom_castTo(o)
SWCom_castTo = _Sword.SWCom_castTo

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

    def __init__(self, *args):
        this = _Sword.new_RawCom(*args)
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _Sword.delete_RawCom
    __del__ = lambda self: None

    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)
    __swig_getmethods__["createModule"] = lambda x: _Sword.RawCom_createModule
    if _newclass:
        createModule = staticmethod(_Sword.RawCom_createModule)

    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)
    __swig_getmethods__["castTo"] = lambda x: _Sword.RawCom_castTo
    if _newclass:
        castTo = staticmethod(_Sword.RawCom_castTo)
RawCom_swigregister = _Sword.RawCom_swigregister
RawCom_swigregister(RawCom)

def RawCom_createModule(*args):
    return _Sword.RawCom_createModule(*args)
RawCom_createModule = _Sword.RawCom_createModule

def RawCom_castTo(o):
    return _Sword.RawCom_castTo(o)
RawCom_castTo = _Sword.RawCom_castTo

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

    def __init__(self, *args):
        this = _Sword.new_zCom(*args)
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _Sword.delete_zCom
    __del__ = lambda self: None

    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)
    __swig_getmethods__["createModule"] = lambda x: _Sword.zCom_createModule
    if _newclass:
        createModule = staticmethod(_Sword.zCom_createModule)

    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)
    __swig_getmethods__["castTo"] = lambda x: _Sword.zCom_castTo
    if _newclass:
        castTo = staticmethod(_Sword.zCom_castTo)
zCom_swigregister = _Sword.zCom_swigregister
zCom_swigregister(zCom)

def zCom_createModule(*args):
    return _Sword.zCom_createModule(*args)
zCom_createModule = _Sword.zCom_createModule

def zCom_castTo(o):
    return _Sword.zCom_castTo(o)
zCom_castTo = _Sword.zCom_castTo

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

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

    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)
    __swig_getmethods__["castTo"] = lambda x: _Sword.SWGenBook_castTo
    if _newclass:
        castTo = staticmethod(_Sword.SWGenBook_castTo)
SWGenBook_swigregister = _Sword.SWGenBook_swigregister
SWGenBook_swigregister(SWGenBook)

def SWGenBook_castTo(o):
    return _Sword.SWGenBook_castTo(o)
SWGenBook_castTo = _Sword.SWGenBook_castTo

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

    def __init__(self, *args):
        this = _Sword.new_RawGenBook(*args)
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _Sword.delete_RawGenBook
    __del__ = lambda self: None

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

    def isWritable(self):
        return _Sword.RawGenBook_isWritable(self)
    __swig_getmethods__["createModule"] = lambda x: _Sword.RawGenBook_createModule
    if _newclass:
        createModule = staticmethod(_Sword.RawGenBook_createModule)

    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)
    __swig_getmethods__["castTo"] = lambda x: _Sword.RawGenBook_castTo
    if _newclass:
        castTo = staticmethod(_Sword.RawGenBook_castTo)
RawGenBook_swigregister = _Sword.RawGenBook_swigregister
RawGenBook_swigregister(RawGenBook)

def RawGenBook_createModule(ipath):
    return _Sword.RawGenBook_createModule(ipath)
RawGenBook_createModule = _Sword.RawGenBook_createModule

def RawGenBook_castTo(o):
    return _Sword.RawGenBook_castTo(o)
RawGenBook_castTo = _Sword.RawGenBook_castTo

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

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

    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)
    __swig_getmethods__["castTo"] = lambda x: _Sword.SWLD_castTo
    if _newclass:
        castTo = staticmethod(_Sword.SWLD_castTo)
SWLD_swigregister = _Sword.SWLD_swigregister
SWLD_swigregister(SWLD)

def SWLD_castTo(o):
    return _Sword.SWLD_castTo(o)
SWLD_castTo = _Sword.SWLD_castTo

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

    def __init__(self, *args):
        this = _Sword.new_RawLD(*args)
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _Sword.delete_RawLD
    __del__ = lambda self: None

    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)
    __swig_getmethods__["createModule"] = lambda x: _Sword.RawLD_createModule
    if _newclass:
        createModule = staticmethod(_Sword.RawLD_createModule)

    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)
    __swig_getmethods__["castTo"] = lambda x: _Sword.RawLD_castTo
    if _newclass:
        castTo = staticmethod(_Sword.RawLD_castTo)
RawLD_swigregister = _Sword.RawLD_swigregister
RawLD_swigregister(RawLD)

def RawLD_createModule(path):
    return _Sword.RawLD_createModule(path)
RawLD_createModule = _Sword.RawLD_createModule

def RawLD_castTo(o):
    return _Sword.RawLD_castTo(o)
RawLD_castTo = _Sword.RawLD_castTo

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

    def __init__(self, *args):
        this = _Sword.new_RawLD4(*args)
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _Sword.delete_RawLD4
    __del__ = lambda self: None

    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)
    __swig_getmethods__["createModule"] = lambda x: _Sword.RawLD4_createModule
    if _newclass:
        createModule = staticmethod(_Sword.RawLD4_createModule)

    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)
    __swig_getmethods__["castTo"] = lambda x: _Sword.RawLD4_castTo
    if _newclass:
        castTo = staticmethod(_Sword.RawLD4_castTo)
RawLD4_swigregister = _Sword.RawLD4_swigregister
RawLD4_swigregister(RawLD4)

def RawLD4_createModule(path):
    return _Sword.RawLD4_createModule(path)
RawLD4_createModule = _Sword.RawLD4_createModule

def RawLD4_castTo(o):
    return _Sword.RawLD4_castTo(o)
RawLD4_castTo = _Sword.RawLD4_castTo

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

    def __init__(self, *args):
        this = _Sword.new_zLD(*args)
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _Sword.delete_zLD
    __del__ = lambda self: None

    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)
    __swig_getmethods__["createModule"] = lambda x: _Sword.zLD_createModule
    if _newclass:
        createModule = staticmethod(_Sword.zLD_createModule)

    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)
    __swig_getmethods__["castTo"] = lambda x: _Sword.zLD_castTo
    if _newclass:
        castTo = staticmethod(_Sword.zLD_castTo)
zLD_swigregister = _Sword.zLD_swigregister
zLD_swigregister(zLD)

def zLD_createModule(path):
    return _Sword.zLD_createModule(path)
zLD_createModule = _Sword.zLD_createModule

def zLD_castTo(o):
    return _Sword.zLD_castTo(o)
zLD_castTo = _Sword.zLD_castTo

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

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

    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)
    __swig_getmethods__["castTo"] = lambda x: _Sword.SWText_castTo
    if _newclass:
        castTo = staticmethod(_Sword.SWText_castTo)
SWText_swigregister = _Sword.SWText_swigregister
SWText_swigregister(SWText)

def SWText_castTo(o):
    return _Sword.SWText_castTo(o)
SWText_castTo = _Sword.SWText_castTo

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

    def __init__(self, *args):
        this = _Sword.new_RawText(*args)
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _Sword.delete_RawText
    __del__ = lambda self: None

    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)
    __swig_getmethods__["createModule"] = lambda x: _Sword.RawText_createModule
    if _newclass:
        createModule = staticmethod(_Sword.RawText_createModule)

    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)
    __swig_getmethods__["castTo"] = lambda x: _Sword.RawText_castTo
    if _newclass:
        castTo = staticmethod(_Sword.RawText_castTo)
RawText_swigregister = _Sword.RawText_swigregister
RawText_swigregister(RawText)

def RawText_createModule(*args):
    return _Sword.RawText_createModule(*args)
RawText_createModule = _Sword.RawText_createModule

def RawText_castTo(o):
    return _Sword.RawText_castTo(o)
RawText_castTo = _Sword.RawText_castTo

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

    def __init__(self, *args):
        this = _Sword.new_zText(*args)
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _Sword.delete_zText
    __del__ = lambda self: None

    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)
    __swig_getmethods__["createModule"] = lambda x: _Sword.zText_createModule
    if _newclass:
        createModule = staticmethod(_Sword.zText_createModule)

    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)
    __swig_getmethods__["castTo"] = lambda x: _Sword.zText_castTo
    if _newclass:
        castTo = staticmethod(_Sword.zText_castTo)
zText_swigregister = _Sword.zText_swigregister
zText_swigregister(zText)

def zText_createModule(*args):
    return _Sword.zText_createModule(*args)
zText_createModule = _Sword.zText_createModule

def zText_castTo(o):
    return _Sword.zText_castTo(o)
zText_castTo = _Sword.zText_castTo

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

    def __init__(self, iConfigPath=None):
        this = _Sword.new_LocaleMgr(iConfigPath)
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _Sword.delete_LocaleMgr
    __del__ = lambda self: None

    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)
    __swig_getmethods__["getSystemLocaleMgr"] = lambda x: _Sword.LocaleMgr_getSystemLocaleMgr
    if _newclass:
        getSystemLocaleMgr = staticmethod(_Sword.LocaleMgr_getSystemLocaleMgr)
    __swig_getmethods__["setSystemLocaleMgr"] = lambda x: _Sword.LocaleMgr_setSystemLocaleMgr
    if _newclass:
        setSystemLocaleMgr = staticmethod(_Sword.LocaleMgr_setSystemLocaleMgr)

    def loadConfigDir(self, ipath):
        return _Sword.LocaleMgr_loadConfigDir(self, ipath)

    def getAvailableLocalesVector(self):
        return _Sword.LocaleMgr_getAvailableLocalesVector(self)
LocaleMgr_swigregister = _Sword.LocaleMgr_swigregister
LocaleMgr_swigregister(LocaleMgr)

def LocaleMgr_getSystemLocaleMgr():
    return _Sword.LocaleMgr_getSystemLocaleMgr()
LocaleMgr_getSystemLocaleMgr = _Sword.LocaleMgr_getSystemLocaleMgr

def LocaleMgr_setSystemLocaleMgr(newLocaleMgr):
    return _Sword.LocaleMgr_setSystemLocaleMgr(newLocaleMgr)
LocaleMgr_setSystemLocaleMgr = _Sword.LocaleMgr_setSystemLocaleMgr

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

    def __init__(self, url):
        this = _Sword.new_URL(url)
        try:
            self.this.append(this)
        except:
            self.this = this

    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)
    __swig_getmethods__["encode"] = lambda x: _Sword.URL_encode
    if _newclass:
        encode = staticmethod(_Sword.URL_encode)
    __swig_getmethods__["decode"] = lambda x: _Sword.URL_decode
    if _newclass:
        decode = staticmethod(_Sword.URL_decode)
    __swig_destroy__ = _Sword.delete_URL
    __del__ = lambda self: None
URL_swigregister = _Sword.URL_swigregister
URL_swigregister(URL)

def URL_encode(urlText):
    return _Sword.URL_encode(urlText)
URL_encode = _Sword.URL_encode

def URL_decode(encodedText):
    return _Sword.URL_decode(encodedText)
URL_decode = _Sword.URL_decode

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

    def __init__(self, *args):
        this = _Sword.new_XMLTag(*args)
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _Sword.delete_XMLTag
    __del__ = lambda self: None

    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 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)
XMLTag_swigregister = _Sword.XMLTag_swigregister
XMLTag_swigregister(XMLTag)

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

    def __init__(self, module, key):
        this = _Sword.new_BasicFilterUserData(module, key)
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _Sword.delete_BasicFilterUserData
    __del__ = lambda self: None
    __swig_setmethods__["module"] = _Sword.BasicFilterUserData_module_set
    __swig_getmethods__["module"] = _Sword.BasicFilterUserData_module_get
    if _newclass:
        module = _swig_property(_Sword.BasicFilterUserData_module_get, _Sword.BasicFilterUserData_module_set)
    __swig_setmethods__["key"] = _Sword.BasicFilterUserData_key_set
    __swig_getmethods__["key"] = _Sword.BasicFilterUserData_key_get
    if _newclass:
        key = _swig_property(_Sword.BasicFilterUserData_key_get, _Sword.BasicFilterUserData_key_set)
    __swig_setmethods__["lastTextNode"] = _Sword.BasicFilterUserData_lastTextNode_set
    __swig_getmethods__["lastTextNode"] = _Sword.BasicFilterUserData_lastTextNode_get
    if _newclass:
        lastTextNode = _swig_property(_Sword.BasicFilterUserData_lastTextNode_get, _Sword.BasicFilterUserData_lastTextNode_set)
    __swig_setmethods__["lastSuspendSegment"] = _Sword.BasicFilterUserData_lastSuspendSegment_set
    __swig_getmethods__["lastSuspendSegment"] = _Sword.BasicFilterUserData_lastSuspendSegment_get
    if _newclass:
        lastSuspendSegment = _swig_property(_Sword.BasicFilterUserData_lastSuspendSegment_get, _Sword.BasicFilterUserData_lastSuspendSegment_set)
    __swig_setmethods__["suspendTextPassThru"] = _Sword.BasicFilterUserData_suspendTextPassThru_set
    __swig_getmethods__["suspendTextPassThru"] = _Sword.BasicFilterUserData_suspendTextPassThru_get
    if _newclass:
        suspendTextPassThru = _swig_property(_Sword.BasicFilterUserData_suspendTextPassThru_get, _Sword.BasicFilterUserData_suspendTextPassThru_set)
    __swig_setmethods__["supressAdjacentWhitespace"] = _Sword.BasicFilterUserData_supressAdjacentWhitespace_set
    __swig_getmethods__["supressAdjacentWhitespace"] = _Sword.BasicFilterUserData_supressAdjacentWhitespace_get
    if _newclass:
        supressAdjacentWhitespace = _swig_property(_Sword.BasicFilterUserData_supressAdjacentWhitespace_get, _Sword.BasicFilterUserData_supressAdjacentWhitespace_set)
BasicFilterUserData_swigregister = _Sword.BasicFilterUserData_swigregister
BasicFilterUserData_swigregister(BasicFilterUserData)

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

    def __init__(self):
        this = _Sword.new_SWBasicFilter()
        try:
            self.this.append(this)
        except:
            self.this = this

    def processText(self, text, key=None, module=None):
        return _Sword.SWBasicFilter_processText(self, text, key, module)
    __swig_destroy__ = _Sword.delete_SWBasicFilter
    __del__ = lambda self: None
SWBasicFilter_swigregister = _Sword.SWBasicFilter_swigregister
SWBasicFilter_swigregister(SWBasicFilter)

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

    def __init__(self):
        this = _Sword.new_OSISHTMLHREF()
        try:
            self.this.append(this)
        except:
            self.this = this

    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
    __del__ = lambda self: None
OSISHTMLHREF_swigregister = _Sword.OSISHTMLHREF_swigregister
OSISHTMLHREF_swigregister(OSISHTMLHREF)

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

    def __init__(self):
        this = _Sword.new_ThMLHTMLHREF()
        try:
            self.this.append(this)
        except:
            self.this = this

    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
    __del__ = lambda self: None
ThMLHTMLHREF_swigregister = _Sword.ThMLHTMLHREF_swigregister
ThMLHTMLHREF_swigregister(ThMLHTMLHREF)

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

    def __init__(self):
        this = _Sword.new_GBFHTMLHREF()
        try:
            self.this.append(this)
        except:
            self.this = this

    def setRenderNoteNumbers(self, val=True):
        return _Sword.GBFHTMLHREF_setRenderNoteNumbers(self, val)
    __swig_destroy__ = _Sword.delete_GBFHTMLHREF
    __del__ = lambda self: None
GBFHTMLHREF_swigregister = _Sword.GBFHTMLHREF_swigregister
GBFHTMLHREF_swigregister(GBFHTMLHREF)

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

    def __init__(self):
        this = _Sword.new_UTF8HTML()
        try:
            self.this.append(this)
        except:
            self.this = this

    def processText(self, text, key=None, module=None):
        return _Sword.UTF8HTML_processText(self, text, key, module)
    __swig_destroy__ = _Sword.delete_UTF8HTML
    __del__ = lambda self: None
UTF8HTML_swigregister = _Sword.UTF8HTML_swigregister
UTF8HTML_swigregister(UTF8HTML)

class MarkupCallback(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, MarkupCallback, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, MarkupCallback, name)
    __repr__ = _swig_repr
    __swig_destroy__ = _Sword.delete_MarkupCallback
    __del__ = lambda self: None

    def run(self, x):
        return _Sword.MarkupCallback_run(self, x)

    def __init__(self):
        if self.__class__ == MarkupCallback:
            _self = None
        else:
            _self = self
        this = _Sword.new_MarkupCallback(_self, )
        try:
            self.this.append(this)
        except:
            self.this = this
    def __disown__(self):
        self.this.disown()
        _Sword.disown_MarkupCallback(self)
        return weakref_proxy(self)
MarkupCallback_swigregister = _Sword.MarkupCallback_swigregister
MarkupCallback_swigregister(MarkupCallback)

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

    def __init__(self, *args):
        this = _Sword.new_MyMarkup(*args)
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _Sword.delete_MyMarkup
    __del__ = lambda self: None

    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)
MyMarkup_swigregister = _Sword.MyMarkup_swigregister
MyMarkup_swigregister(MyMarkup)


_Sword.FAILED_swigconstant(_Sword)
FAILED = _Sword.FAILED

_Sword.SUCCEEDED_swigconstant(_Sword)
SUCCEEDED = _Sword.SUCCEEDED

_Sword.INHERITED_swigconstant(_Sword)
INHERITED = _Sword.INHERITED
class ReturnSuccess(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ReturnSuccess, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ReturnSuccess, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _Sword.new_ReturnSuccess(*args)
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _Sword.delete_ReturnSuccess
    __del__ = lambda self: None
    __swig_setmethods__["data"] = _Sword.ReturnSuccess_data_set
    __swig_getmethods__["data"] = _Sword.ReturnSuccess_data_get
    if _newclass:
        data = _swig_property(_Sword.ReturnSuccess_data_get, _Sword.ReturnSuccess_data_set)
    __swig_setmethods__["success"] = _Sword.ReturnSuccess_success_set
    __swig_getmethods__["success"] = _Sword.ReturnSuccess_success_get
    if _newclass:
        success = _swig_property(_Sword.ReturnSuccess_success_get, _Sword.ReturnSuccess_success_set)
ReturnSuccess_swigregister = _Sword.ReturnSuccess_swigregister
ReturnSuccess_swigregister(ReturnSuccess)

class RenderCallback(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, RenderCallback, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, RenderCallback, name)
    __repr__ = _swig_repr
    __swig_destroy__ = _Sword.delete_RenderCallback
    __del__ = lambda self: None

    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
        this = _Sword.new_RenderCallback(_self, )
        try:
            self.this.append(this)
        except:
            self.this = this
    def __disown__(self):
        self.this.disown()
        _Sword.disown_RenderCallback(self)
        return weakref_proxy(self)
RenderCallback_swigregister = _Sword.RenderCallback_swigregister
RenderCallback_swigregister(RenderCallback)

class PyOSISHTMLHREF(OSISHTMLHREF):
    __swig_setmethods__ = {}
    for _s in [OSISHTMLHREF]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, PyOSISHTMLHREF, name, value)
    __swig_getmethods__ = {}
    for _s in [OSISHTMLHREF]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, PyOSISHTMLHREF, name)
    __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):
        this = _Sword.new_PyOSISHTMLHREF(callback)
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_getmethods__["getData"] = lambda x: _Sword.PyOSISHTMLHREF_getData
    if _newclass:
        getData = staticmethod(_Sword.PyOSISHTMLHREF_getData)
    __swig_destroy__ = _Sword.delete_PyOSISHTMLHREF
    __del__ = lambda self: None

    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)
PyOSISHTMLHREF_swigregister = _Sword.PyOSISHTMLHREF_swigregister
PyOSISHTMLHREF_swigregister(PyOSISHTMLHREF)

def PyOSISHTMLHREF_getData(f):
    return _Sword.PyOSISHTMLHREF_getData(f)
PyOSISHTMLHREF_getData = _Sword.PyOSISHTMLHREF_getData

class PyThMLHTMLHREF(ThMLHTMLHREF):
    __swig_setmethods__ = {}
    for _s in [ThMLHTMLHREF]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, PyThMLHTMLHREF, name, value)
    __swig_getmethods__ = {}
    for _s in [ThMLHTMLHREF]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, PyThMLHTMLHREF, name)
    __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):
        this = _Sword.new_PyThMLHTMLHREF(callback)
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_getmethods__["getData"] = lambda x: _Sword.PyThMLHTMLHREF_getData
    if _newclass:
        getData = staticmethod(_Sword.PyThMLHTMLHREF_getData)
    __swig_destroy__ = _Sword.delete_PyThMLHTMLHREF
    __del__ = lambda self: None

    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)
PyThMLHTMLHREF_swigregister = _Sword.PyThMLHTMLHREF_swigregister
PyThMLHTMLHREF_swigregister(PyThMLHTMLHREF)

def PyThMLHTMLHREF_getData(f):
    return _Sword.PyThMLHTMLHREF_getData(f)
PyThMLHTMLHREF_getData = _Sword.PyThMLHTMLHREF_getData

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

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    __swig_setmethods__["osisQToTick"] = _Sword.OSISData_osisQToTick_set
    __swig_getmethods__["osisQToTick"] = _Sword.OSISData_osisQToTick_get
    if _newclass:
        osisQToTick = _swig_property(_Sword.OSISData_osisQToTick_get, _Sword.OSISData_osisQToTick_set)
    __swig_setmethods__["inBold"] = _Sword.OSISData_inBold_set
    __swig_getmethods__["inBold"] = _Sword.OSISData_inBold_get
    if _newclass:
        inBold = _swig_property(_Sword.OSISData_inBold_get, _Sword.OSISData_inBold_set)
    __swig_setmethods__["inXRefNote"] = _Sword.OSISData_inXRefNote_set
    __swig_getmethods__["inXRefNote"] = _Sword.OSISData_inXRefNote_get
    if _newclass:
        inXRefNote = _swig_property(_Sword.OSISData_inXRefNote_get, _Sword.OSISData_inXRefNote_set)
    __swig_setmethods__["BiblicalText"] = _Sword.OSISData_BiblicalText_set
    __swig_getmethods__["BiblicalText"] = _Sword.OSISData_BiblicalText_get
    if _newclass:
        BiblicalText = _swig_property(_Sword.OSISData_BiblicalText_get, _Sword.OSISData_BiblicalText_set)
    __swig_setmethods__["suspendLevel"] = _Sword.OSISData_suspendLevel_set
    __swig_getmethods__["suspendLevel"] = _Sword.OSISData_suspendLevel_get
    if _newclass:
        suspendLevel = _swig_property(_Sword.OSISData_suspendLevel_get, _Sword.OSISData_suspendLevel_set)
    __swig_setmethods__["wordsOfChristStart"] = _Sword.OSISData_wordsOfChristStart_set
    __swig_getmethods__["wordsOfChristStart"] = _Sword.OSISData_wordsOfChristStart_get
    if _newclass:
        wordsOfChristStart = _swig_property(_Sword.OSISData_wordsOfChristStart_get, _Sword.OSISData_wordsOfChristStart_set)
    __swig_setmethods__["wordsOfChristEnd"] = _Sword.OSISData_wordsOfChristEnd_set
    __swig_getmethods__["wordsOfChristEnd"] = _Sword.OSISData_wordsOfChristEnd_get
    if _newclass:
        wordsOfChristEnd = _swig_property(_Sword.OSISData_wordsOfChristEnd_get, _Sword.OSISData_wordsOfChristEnd_set)
    __swig_setmethods__["lastTransChange"] = _Sword.OSISData_lastTransChange_set
    __swig_getmethods__["lastTransChange"] = _Sword.OSISData_lastTransChange_get
    if _newclass:
        lastTransChange = _swig_property(_Sword.OSISData_lastTransChange_get, _Sword.OSISData_lastTransChange_set)
    __swig_setmethods__["w"] = _Sword.OSISData_w_set
    __swig_getmethods__["w"] = _Sword.OSISData_w_get
    if _newclass:
        w = _swig_property(_Sword.OSISData_w_get, _Sword.OSISData_w_set)
    __swig_setmethods__["fn"] = _Sword.OSISData_fn_set
    __swig_getmethods__["fn"] = _Sword.OSISData_fn_get
    if _newclass:
        fn = _swig_property(_Sword.OSISData_fn_get, _Sword.OSISData_fn_set)
    __swig_setmethods__["version"] = _Sword.OSISData_version_set
    __swig_getmethods__["version"] = _Sword.OSISData_version_get
    if _newclass:
        version = _swig_property(_Sword.OSISData_version_get, _Sword.OSISData_version_set)
    __swig_destroy__ = _Sword.delete_OSISData
    __del__ = lambda self: None
OSISData_swigregister = _Sword.OSISData_swigregister
OSISData_swigregister(OSISData)

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

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    __swig_setmethods__["inscriptRef"] = _Sword.ThMLData_inscriptRef_set
    __swig_getmethods__["inscriptRef"] = _Sword.ThMLData_inscriptRef_get
    if _newclass:
        inscriptRef = _swig_property(_Sword.ThMLData_inscriptRef_get, _Sword.ThMLData_inscriptRef_set)
    __swig_setmethods__["SecHead"] = _Sword.ThMLData_SecHead_set
    __swig_getmethods__["SecHead"] = _Sword.ThMLData_SecHead_get
    if _newclass:
        SecHead = _swig_property(_Sword.ThMLData_SecHead_get, _Sword.ThMLData_SecHead_set)
    __swig_setmethods__["BiblicalText"] = _Sword.ThMLData_BiblicalText_set
    __swig_getmethods__["BiblicalText"] = _Sword.ThMLData_BiblicalText_get
    if _newclass:
        BiblicalText = _swig_property(_Sword.ThMLData_BiblicalText_get, _Sword.ThMLData_BiblicalText_set)
    __swig_setmethods__["version"] = _Sword.ThMLData_version_set
    __swig_getmethods__["version"] = _Sword.ThMLData_version_get
    if _newclass:
        version = _swig_property(_Sword.ThMLData_version_get, _Sword.ThMLData_version_set)
    __swig_setmethods__["startTag"] = _Sword.ThMLData_startTag_set
    __swig_getmethods__["startTag"] = _Sword.ThMLData_startTag_get
    if _newclass:
        startTag = _swig_property(_Sword.ThMLData_startTag_get, _Sword.ThMLData_startTag_set)
    __swig_destroy__ = _Sword.delete_ThMLData
    __del__ = lambda self: None
ThMLData_swigregister = _Sword.ThMLData_swigregister
ThMLData_swigregister(ThMLData)

class SWSearcher(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, SWSearcher, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, SWSearcher, name)
    __repr__ = _swig_repr
    __swig_setmethods__["mod"] = _Sword.SWSearcher_mod_set
    __swig_getmethods__["mod"] = _Sword.SWSearcher_mod_get
    if _newclass:
        mod = _swig_property(_Sword.SWSearcher_mod_get, _Sword.SWSearcher_mod_set)
    __swig_setmethods__["percent"] = _Sword.SWSearcher_percent_set
    __swig_getmethods__["percent"] = _Sword.SWSearcher_percent_get
    if _newclass:
        percent = _swig_property(_Sword.SWSearcher_percent_get, _Sword.SWSearcher_percent_set)
    __swig_getmethods__["Callback"] = lambda x: _Sword.SWSearcher_Callback
    if _newclass:
        Callback = staticmethod(_Sword.SWSearcher_Callback)

    def PercentFunction(self, value):
        return _Sword.SWSearcher_PercentFunction(self, value)

    def __init__(self, Mod):
        if self.__class__ == SWSearcher:
            _self = None
        else:
            _self = self
        this = _Sword.new_SWSearcher(_self, Mod)
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _Sword.delete_SWSearcher
    __del__ = lambda self: None

    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)
SWSearcher_swigregister = _Sword.SWSearcher_swigregister
SWSearcher_swigregister(SWSearcher)

def SWSearcher_Callback(status, me):
    return _Sword.SWSearcher_Callback(status, me)
SWSearcher_Callback = _Sword.SWSearcher_Callback

class SWLog(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, SWLog, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, SWLog, name)
    __repr__ = _swig_repr
    __swig_getmethods__["getSystemLog"] = lambda x: _Sword.SWLog_getSystemLog
    if _newclass:
        getSystemLog = staticmethod(_Sword.SWLog_getSystemLog)
    __swig_getmethods__["setSystemLog"] = lambda x: _Sword.SWLog_setSystemLog
    if _newclass:
        setSystemLog = staticmethod(_Sword.SWLog_setSystemLog)

    def __init__(self):
        this = _Sword.new_SWLog()
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _Sword.delete_SWLog
    __del__ = lambda self: None

    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 logTimedInformation(self, fmt):
        return _Sword.SWLog_logTimedInformation(self, fmt)

    def logDebug(self, fmt):
        return _Sword.SWLog_logDebug(self, fmt)

    def logMessage(self, message, level):
        return _Sword.SWLog_logMessage(self, message, level)
SWLog_swigregister = _Sword.SWLog_swigregister
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

def SWLog_getSystemLog():
    return _Sword.SWLog_getSystemLog()
SWLog_getSystemLog = _Sword.SWLog_getSystemLog

def SWLog_setSystemLog(newLogger):
    return _Sword.SWLog_setSystemLog(newLogger)
SWLog_setSystemLog = _Sword.SWLog_setSystemLog

class StatusReporter(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, StatusReporter, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, StatusReporter, name)
    __repr__ = _swig_repr
    __swig_destroy__ = _Sword.delete_StatusReporter
    __del__ = lambda self: None

    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
        this = _Sword.new_StatusReporter(_self, )
        try:
            self.this.append(this)
        except:
            self.this = this
    def __disown__(self):
        self.this.disown()
        _Sword.disown_StatusReporter(self)
        return weakref_proxy(self)
StatusReporter_swigregister = _Sword.StatusReporter_swigregister
StatusReporter_swigregister(StatusReporter)

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

    def __init__(self, host, statusReporter=None):
        this = _Sword.new_RemoteTransport(host, statusReporter)
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _Sword.delete_RemoteTransport
    __del__ = lambda self: None

    def getURL(self, destPath, sourceURL, destBuf=None):
        return _Sword.RemoteTransport_getURL(self, destPath, sourceURL, destBuf)

    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 setUser(self, user):
        return _Sword.RemoteTransport_setUser(self, user)

    def setPasswd(self, passwd):
        return _Sword.RemoteTransport_setPasswd(self, passwd)

    def terminate(self):
        return _Sword.RemoteTransport_terminate(self)
RemoteTransport_swigregister = _Sword.RemoteTransport_swigregister
RemoteTransport_swigregister(RemoteTransport)

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

    def __init__(self, type, confEnt=None):
        this = _Sword.new_InstallSource(type, confEnt)
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _Sword.delete_InstallSource
    __del__ = lambda self: None

    def getConfEnt(self):
        return _Sword.InstallSource_getConfEnt(self)
    __swig_setmethods__["caption"] = _Sword.InstallSource_caption_set
    __swig_getmethods__["caption"] = _Sword.InstallSource_caption_get
    if _newclass:
        caption = _swig_property(_Sword.InstallSource_caption_get, _Sword.InstallSource_caption_set)
    __swig_setmethods__["source"] = _Sword.InstallSource_source_set
    __swig_getmethods__["source"] = _Sword.InstallSource_source_get
    if _newclass:
        source = _swig_property(_Sword.InstallSource_source_get, _Sword.InstallSource_source_set)
    __swig_setmethods__["directory"] = _Sword.InstallSource_directory_set
    __swig_getmethods__["directory"] = _Sword.InstallSource_directory_get
    if _newclass:
        directory = _swig_property(_Sword.InstallSource_directory_get, _Sword.InstallSource_directory_set)
    __swig_setmethods__["u"] = _Sword.InstallSource_u_set
    __swig_getmethods__["u"] = _Sword.InstallSource_u_get
    if _newclass:
        u = _swig_property(_Sword.InstallSource_u_get, _Sword.InstallSource_u_set)
    __swig_setmethods__["p"] = _Sword.InstallSource_p_set
    __swig_getmethods__["p"] = _Sword.InstallSource_p_get
    if _newclass:
        p = _swig_property(_Sword.InstallSource_p_get, _Sword.InstallSource_p_set)
    __swig_setmethods__["uid"] = _Sword.InstallSource_uid_set
    __swig_getmethods__["uid"] = _Sword.InstallSource_uid_get
    if _newclass:
        uid = _swig_property(_Sword.InstallSource_uid_get, _Sword.InstallSource_uid_set)
    __swig_setmethods__["type"] = _Sword.InstallSource_type_set
    __swig_getmethods__["type"] = _Sword.InstallSource_type_get
    if _newclass:
        type = _swig_property(_Sword.InstallSource_type_get, _Sword.InstallSource_type_set)
    __swig_setmethods__["localShadow"] = _Sword.InstallSource_localShadow_set
    __swig_getmethods__["localShadow"] = _Sword.InstallSource_localShadow_get
    if _newclass:
        localShadow = _swig_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)
InstallSource_swigregister = _Sword.InstallSource_swigregister
InstallSource_swigregister(InstallSource)

class InstallMgr(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, InstallMgr, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, InstallMgr, name)
    __repr__ = _swig_repr
    __swig_setmethods__["installConf"] = _Sword.InstallMgr_installConf_set
    __swig_getmethods__["installConf"] = _Sword.InstallMgr_installConf_get
    if _newclass:
        installConf = _swig_property(_Sword.InstallMgr_installConf_get, _Sword.InstallMgr_installConf_set)
    __swig_setmethods__["sources"] = _Sword.InstallMgr_sources_set
    __swig_getmethods__["sources"] = _Sword.InstallMgr_sources_get
    if _newclass:
        sources = _swig_property(_Sword.InstallMgr_sources_get, _Sword.InstallMgr_sources_set)

    def __init__(self, *args):
        this = _Sword.new_InstallMgr(*args)
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _Sword.delete_InstallMgr
    __del__ = lambda self: None

    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, arg5=None):
        return _Sword.InstallMgr_installModule(self, destMgr, fromLocation, modName, arg5)

    def refreshRemoteSource(self, arg2):
        return _Sword.InstallMgr_refreshRemoteSource(self, arg2)

    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 terminate(self):
        return _Sword.InstallMgr_terminate(self)
    __swig_getmethods__["getModuleStatus"] = lambda x: _Sword.InstallMgr_getModuleStatus
    if _newclass:
        getModuleStatus = staticmethod(_Sword.InstallMgr_getModuleStatus)

    def isDefaultModule(self, modName):
        return _Sword.InstallMgr_isDefaultModule(self, modName)
InstallMgr_swigregister = _Sword.InstallMgr_swigregister
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

def InstallMgr_getModuleStatus(base, other):
    return _Sword.InstallMgr_getModuleStatus(base, other)
InstallMgr_getModuleStatus = _Sword.InstallMgr_getModuleStatus

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


