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

from sys import version_info as _swig_python_version_info
# Import the low-level C/C++ module
if __package__ or "." in __name__:
    from . import _apertium_core
else:
    import _apertium_core

try:
    import builtins as __builtin__
except ImportError:
    import __builtin__

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


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


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


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


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


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

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

    def read(self, transferfile, datafile):
        return _apertium_core.TransferBase_read(self, transferfile, datafile)

    def getNullFlush(self):
        return _apertium_core.TransferBase_getNullFlush(self)

    def setNullFlush(self, null_flush):
        return _apertium_core.TransferBase_setNullFlush(self, null_flush)

    def setTrace(self, trace):
        return _apertium_core.TransferBase_setTrace(self, trace)

    def setDictionaryCase(self, val):
        return _apertium_core.TransferBase_setDictionaryCase(self, val)

# Register TransferBase in _apertium_core:
_apertium_core.TransferBase_swigregister(TransferBase)
class Interchunk(TransferBase):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self):
        _apertium_core.Interchunk_swiginit(self, _apertium_core.new_Interchunk())

    def interchunk(self, _in, out):
        return _apertium_core.Interchunk_interchunk(self, _in, out)
    __swig_destroy__ = _apertium_core.delete_Interchunk

# Register Interchunk in _apertium_core:
_apertium_core.Interchunk_swigregister(Interchunk)

def storeAndWriteWblank(input, output):
    return _apertium_core.storeAndWriteWblank(input, output)

def readAndWriteUntil(input, output, charcode):
    return _apertium_core.readAndWriteUntil(input, output, charcode)

def procWord(input, output, surface_forms, compound_sep, wblank):
    return _apertium_core.procWord(input, output, surface_forms, compound_sep, wblank)

def processStream(input, output, null_flush, surface_forms, compound_sep):
    return _apertium_core.processStream(input, output, null_flush, surface_forms, compound_sep)
class Postchunk(TransferBase):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self):
        _apertium_core.Postchunk_swiginit(self, _apertium_core.new_Postchunk())

    def postchunk(self, _in, out):
        return _apertium_core.Postchunk_postchunk(self, _in, out)
    __swig_destroy__ = _apertium_core.delete_Postchunk

# Register Postchunk in _apertium_core:
_apertium_core.Postchunk_swigregister(Postchunk)
class apertium_tagger(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, argc, argv):
        _apertium_core.apertium_tagger_swiginit(self, _apertium_core.new_apertium_tagger(argc, argv))
    __swig_destroy__ = _apertium_core.delete_apertium_tagger

# Register apertium_tagger in _apertium_core:
_apertium_core.apertium_tagger_swigregister(apertium_tagger)
class Transfer(TransferBase):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self):
        _apertium_core.Transfer_swiginit(self, _apertium_core.new_Transfer())

    def read(self, *args):
        return _apertium_core.Transfer_read(self, *args)

    def transfer(self, _in, out):
        return _apertium_core.Transfer_transfer(self, _in, out)

    def setUseBilingual(self, value):
        return _apertium_core.Transfer_setUseBilingual(self, value)

    def getUseBilingual(self):
        return _apertium_core.Transfer_getUseBilingual(self)

    def setPreBilingual(self, value):
        return _apertium_core.Transfer_setPreBilingual(self, value)

    def getPreBilingual(self):
        return _apertium_core.Transfer_getPreBilingual(self)

    def setExtendedDictionary(self, fstfile):
        return _apertium_core.Transfer_setExtendedDictionary(self, fstfile)

    def setCaseSensitiveness(self, value):
        return _apertium_core.Transfer_setCaseSensitiveness(self, value)

    def setTraceATT(self, trace):
        return _apertium_core.Transfer_setTraceATT(self, trace)
    __swig_destroy__ = _apertium_core.delete_Transfer

# Register Transfer in _apertium_core:
_apertium_core.Transfer_swigregister(Transfer)

def pretransfer(argc, input_path, output_path):
    return _apertium_core.pretransfer(argc, input_path, output_path)
class ApertiumTransferBase(TransferBase):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

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

# Register ApertiumTransferBase in _apertium_core:
_apertium_core.ApertiumTransferBase_swigregister(ApertiumTransferBase)
class ApertiumTransfer(Transfer):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, transferfile, datafile):
        _apertium_core.ApertiumTransfer_swiginit(self, _apertium_core.new_ApertiumTransfer(transferfile, datafile))

    def transfer_text(self, argc, input_path, output_path):
        return _apertium_core.ApertiumTransfer_transfer_text(self, argc, input_path, output_path)
    __swig_destroy__ = _apertium_core.delete_ApertiumTransfer

# Register ApertiumTransfer in _apertium_core:
_apertium_core.ApertiumTransfer_swigregister(ApertiumTransfer)
class ApertiumTagger(apertium_tagger):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, argc):
        _apertium_core.ApertiumTagger_swiginit(self, _apertium_core.new_ApertiumTagger(argc))
    __swig_destroy__ = _apertium_core.delete_ApertiumTagger

# Register ApertiumTagger in _apertium_core:
_apertium_core.ApertiumTagger_swigregister(ApertiumTagger)
class ApertiumInterchunk(Interchunk):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, transferfile, datafile):
        _apertium_core.ApertiumInterchunk_swiginit(self, _apertium_core.new_ApertiumInterchunk(transferfile, datafile))

    def interchunk_text(self, argc, input_path, output_path):
        return _apertium_core.ApertiumInterchunk_interchunk_text(self, argc, input_path, output_path)
    __swig_destroy__ = _apertium_core.delete_ApertiumInterchunk

# Register ApertiumInterchunk in _apertium_core:
_apertium_core.ApertiumInterchunk_swigregister(ApertiumInterchunk)
class ApertiumPostchunk(Postchunk):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, transferfile, datafile):
        _apertium_core.ApertiumPostchunk_swiginit(self, _apertium_core.new_ApertiumPostchunk(transferfile, datafile))

    def postchunk_text(self, argc, input_path, output_path):
        return _apertium_core.ApertiumPostchunk_postchunk_text(self, argc, input_path, output_path)
    __swig_destroy__ = _apertium_core.delete_ApertiumPostchunk

# Register ApertiumPostchunk in _apertium_core:
_apertium_core.ApertiumPostchunk_swigregister(ApertiumPostchunk)

